Spring学习笔记(3)


阅读数: 次   

文章导航

Spring学习笔记

🐭⛅☔

AOP面向切面编程，动态代理，注解实现AOP，配置实现AOP…

AOP

简介

AOP(Aspect Oriented Programming)意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP（面向对象编程）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发效率。

面向切面编程：基于OOP基础之上新的编程思想；

在程序运行期间，将某段代码动态的切入到指定方法的指定位置进行运行的这种编程方式，就叫面向切面编程。

动态代理

一. 优缺点

  • jdk默认的动态代理，如果目标对象没有实现任何接口，是无法为他创建对象的，手写麻烦;
  • 可以使用动态代理将日志代码动态的在目标方法执行前后先执行。

二. 实现

1). 代理对象生成类

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
package com.AAA.teng.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import com.AAA.teng.inter.Calculator;
import com.AAA.teng.utils.LogUtils;


/**
 * 帮Calculator生成代理对象
 * @author 腾飞
 *
 */
public class CalculatorProxy {

	/**
	 * 为传入的参数对象创建一个动态代理对象
	 * @param calculator
	 * @return
	 */
	public static Calculator getProxy(Calculator calculator) {
		
		ClassLoader loader = calculator.getClass().getClassLoader();
		Class<?>[] interfaces = calculator.getClass().getInterfaces();
		//目标方法执行器
		InvocationHandler h = new InvocationHandler() {			
			/**
			 * Object proxy:代理对象，给jdk使用，任何时候都不要动;
			 * Method method:当前将要执行的目标对象
			 * Object[] args:这个方法调用外界传入的参数值
			 */
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				//目标方法执行后的返回值
				Object result = null;
				try{
					LogUtils.logStart(method,args);
					//利用反射执行目标方法	
					result = method.invoke(calculator, args);
					LogUtils.logReturn(method, result);
				}catch(Exception e){
					LogUtils.logException(method, e);
				}finally{
					LogUtils.logEnd(method);
				}
				//返回值必须返回出去，外界才能拿到真正执行后的返回值
				return result;
			}
		};		
		//Proxy为目标对象创建代理对象
		Object proxy = Proxy.newProxyInstance(loader, interfaces, h);
		//返回代理对象
		return (Calculator)proxy;
	}
}

2). 接口和方法

1
2
3
4
5
6
public interface Calculator {
	public int add(int i,int j);
	public int sub(int i,int j);
	public int mul(int i,int j);
	public int div(int i,int j);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class MyMathCalculator implements Calculator{
	@Override
	public int add(int i,int j){
		int result = i + j;
		return result;
	}
	@Override
	public int sub(int i, int j) {
		int result = i - j;
		return result;
	}
	@Override
	public int mul(int i, int j) {
		int result = i * j;
		return result;
	}
	@Override
	public int div(int i, int j) {
		int result = i / j;
		return result;
	}
}

3). 工具类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class LogUtils {
	public static void logStart(Method method,Object... args){
		System.out.println("【"+method.getName()+"】方法开始执行，用的参数列表【"+Arrays.asList(args)+"】");
	}
	public static void logReturn(Method method,Object result){
		System.out.println("【"+method.getName()+"】方法执行完成，计算结果是："+result);
	}
	public static void logException(Method method,Exception e){
		System.out.println("【"+method.getName()+"】方法执行出现异常，异常信息是："+e.getCause());
	}
	public static void logEnd(Method method){
		System.out.println("【"+method.getName()+"】方法执行结束！");
	}
}

4). 测试类

1
2
3
4
5
6
7
8
9
10
11
public static void main(String[] args) {
	Calculator calculator = new MyMathCalculator();
	calculator.add(3, 8);
	
	//如果是拿了这个对象的代理对象，代理对象执行；
	Calculator proxy = CalculatorProxy.getProxy(calculator);
	//代理对象和被代理对象唯一能产生的关联就是实现拿了同一个接口
	System.out.println("代理对象类型:"+proxy.getClass());
	System.out.println("代理对象实现的接口类型:"+Arrays.asList(proxy.getClass().getInterfaces()));
	proxy.div(24, 3);
}

面向切面编程

Spring实现AOP

一. 原理:

Spring实现了AOP功能，底层就是动态代理，Spring简化了面向切面编程；

二. 优缺点

可以利用Spring简单的去创建动态代理，实现简单，而且没有强制要求目标对象必须实现接口;

1). AOP使用场景：

  • AOP加日志保存到数据库；
  • AOP做权限验证；
  • AOP做权限检查
  • AOP做事务控制；

三. AOP图解

1). 切入点表达式作用

通过表达式的方式定位一个或多个具体的连接点。

2). 通知：

  • 在具体的连接点上要执行的操作。
  • 一个切面可以包括一个或者多个通知。
  • 通知所使用的注解的值往往是切入点表达式。

3). 指定切面的优先级：

  • 在同一个连接点上应用不止一个切面时，除非明确指定，否则它们的优先级是不确定的。
  • 切面的优先级可以通过实现Ordered接口或利用@Order注解指定。
  • 实现Ordered接口，getOrder()方法的返回值越小，优先级越高。

面向切面编程

四. 实现

1). 导入jar包

AspectJ简介：

  • AspectJ：Java社区里最完整最流行的AOP框架。
  • 在Spring2.0以上版本中，可以使用基于AspectJ注解或基于XML配置的AOP。
  • @AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面新版本Spring框架，建议使用AspectJ方式来开发AOP。

jar包

1
2
3
4
5
6
7
//基础版
//spring-aspects-4.3.9.RELEASE.jar    

//加强版的面向切面编程(即使目标对象没有实现任何接口也能创建动态代理)
//com.springsource.net.sf.cglib-2.2.0.jar
//com.springsource.org.aopalliance-1.0.0.jar
//com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

2). 配置文件

①. 通过注解形式 将对象增加到 ioc容器时，需要设置 扫描器<context:component-scan base-package="com.AAA.teng"></context:component-scan>；

②. 扫描器 会将 指定的包 中的 @Componet @Service @Respository @Controller修饰的类产生的对象 增加到IOC容器中;

③. @Aspect不需要 加入扫描器，只需要开启即可：<aop:aspectj-autoproxy></aop:aspectj-autoproxy>;

1
2
3
4
5
6
7
8
9
10
11
	 <!--
	 	1.将目标类和切面类（封装了通知方法(在目标方法执行前后执行的方法)）加入到ioc容器中
	 	2.@Aspect标注切面类
	 	3.确定切面类中的方法什么时候运行
	 -->
	 <context:component-scan base-package="com.AAA.teng">
	 </context:component-scan>
	 
	 <!-- 开启注解的AOP模式 :AOP的命名空间-->
	 <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

3). 方法类

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 MyMathCalculator /*implements Calculator*/{
	
 	//@Override
	public int add(int i,int j){
		int result = i + j;
		return result;
	}
	
    //@Override
	public int sub(int i, int j) {
		int result = i - j;
		return result;
	}

	//@Override
	public int mul(int i, int j) {
		int result = i * j;
		return result;
	}

	//@Override
	public int div(int i, int j) {
		int result = i / j;
		return result;
	}
}

4). 工具类

①. 当在Spring IOC容器中初始化AspectJ切面之后，Spring IOC容器就会为那些与 AspectJ切面相匹配的bean创建代理。

②. AspectJ支持5种类型的通知注解：
[1]@Before：前置通知，在方法执行之前执行
[2]@After：后置通知，在方法执行之后执行
[3]@AfterRunning：返回通知，在方法返回结果之后执行
[4]@AfterThrowing：异常通知，在方法抛出异常之后执行
[5]@Around：环绕通知，围绕着方法执行

③. 在AspectJ注解中，切面只是一个带有@Aspect注解的Java类，它往往要包含很多通知。

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
71
72
73
74
75
76
77
78
79
80
81
82
83
/**
 * 如何将这个类（切面类）中的一些方法（通知方法）动态的切入到目标方法的各个位置
 * @author 腾飞
 *
 */
@Aspect
@Component
public class LogUtils {

	/**
	 * 告诉Spring每个方法都什么时候运行（通知注解）
	 * @Before:在目标方法之前运行				前置通知
	 * @AfterReturning:在目标方法正常返回之后	  返回通知
	 * @AfterThrowing:在目标方法抛出异常之后运行	 异常通知
	 * @After:在目标方法结束之后				后置通知
	 * @Around:环绕						环绕通知
	 */
	
	/**
	 * 抽取可重用方法
	 * 1.声明一个没有实现的空方法
	 * 
	 */
	@Pointcut("execution(public int com.AAA.teng.impl.MyMathCalculator.*(..))")
	public void MyPoint(){};
		
	//在目标方法之前运行，写入切入点表达式
	//execution(返回权限符 返回值类型 方法签名(参数表) )
	@Before("MyPoint()")
	public static void logStart(JoinPoint joinPoint){
		//获取到目标方法运行时使用的参数
		Object[] args = joinPoint.getArgs();
		//获取到方法签名
		Signature signature = joinPoint.getSignature();
		System.out.println("【"+signature.getName()+"】方法开始执行，用的参数列表【"+Arrays.asList(args)+"】");
	}
	/**
	 * 固定格式：execution(返回权限符 返回值类型 方法签名(参数表) )
	 * 通配符
	 * 	*:	1.匹配一个或者多个字符
	 * 	  	2.匹配任意一个参数
	 * 	  	3.只能匹配一层路径
	 * 		4.所有权限不能写*，可以直接不写
	 * 	..:	1.匹配任意多个参数
	 * 		2.可以匹配任意多层路径
	 * 
	 * 逻辑表达式
	 *  &&：我们切入的位置要同时满足这两个表达式
	 *  ||：满足任意一个表达式即可
	 *  !：不满足表达式即可
	 *  
	 * 告诉Spring用result来接收返回值
	 * 	returning="result":接收返回值
	 * 	throwing="e":接收异常
	 */
	@AfterReturning(value="MyPoint()",returning="result")
	public static void logReturn(JoinPoint joinPoint,Object result){
		//获取到方法签名
		Signature signature = joinPoint.getSignature();
		System.out.println("【"+signature.getName()+"】方法执行完成，计算结果是："+result);
	}
	
	/**
	 * 在通知方法运行的时候，拿到目标方法的详细信息；
	 * 1.在通知方法的参数列表上写一个参数
	 * 		JoinPoint joinPoint：封装了当前目标方法的详细信息
	 */
	@AfterThrowing(value="MyPoint()",throwing="e")
	public static void logException(JoinPoint joinPoint,Exception e){
		System.out.println("【"+joinPoint.getSignature().getName()+"】方法执行出现异常，异常信息是："+e);
	}
	
	/**
	 * Spring对通知方法不严格，唯一要求方法参数列表不能乱写
	 * 	通知方法是Spring利用反射调用的，每次方法调用得确定这个方法的参数值
	 * @param joinPoint
	 * 	自己设置参数
	 */
	@After("MyPoint()")
	public static void logEnd(JoinPoint joinPoint){
		System.out.println("【"+joinPoint.getSignature().getName()+"】方法执行结束！");
	}
}

5). 测试类

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
public class AOPTest {

	ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");

	@Test
	public void Test() {
	
		//从ioc容器中拿到目标对象，注意：如果想要用类型，一定要他的接口类型，不要用它的类
		Calculator bean = ioc.getBean(Calculator.class);
		bean.div(24, 8);
		//AOP的底层就是动态代理，容器中保存的组件是他的代理对象
		System.out.println(bean);
		System.out.println(bean.getClass());
		
		//用id来获取对象
		Calculator bean2 = (Calculator)ioc.getBean("myMathCalculator");
		System.out.println(bean2.getClass());
	}
	
	/**
	 * 没有接口
	 */
	@Test
	public void Test2() {
		
		//没有接口，Spring会用cglib来创建对象
		MyMathCalculator bean = ioc.getBean(MyMathCalculator.class);
		bean.sub(10, 12);
		System.out.println(bean.getClass());
		
		//用id来获取对象,没有接口就用类对象
		MyMathCalculator bean2 = (MyMathCalculator)ioc.getBean("myMathCalculator");
		System.out.println(bean2.getClass());
	}
	
	/**
	 * 通知方法的执行循序
	 * 正常执行：@Before（前置通知）===》@After（后置通知）===》AfterReturning（正常返回）
	 * 异常执行：@Before（前置通知）===》@After（后置通知）===》AfterThrowing（方法异常）
	 */
	@Test
	public void Test3() {		
		MyMathCalculator bean = ioc.getBean(MyMathCalculator.class);
		bean.sub(10, 12);
		bean.div(13, 0);
	}
}

通知方法

6). 环绕通知

环绕通知：

  • 在目标方法的前后、异常发生时、最终等各个地方都可以进行的通知，最强大的一个通知，类似一个动态代理，可以影响目标方法;
  • 可以获取目标方法的 全部控制权（目标方法是否执行、执行之前、执行之后、参数、返回值等）;
  • 在使用环绕通知时，目标方法的一切信息 都可以通过invocation参数获取到;
  • 环绕通知 底层是通过拦截器实现的;
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
@Aspect
@Component
public class LogUtils {
 	/**
	 * 抽取可重用方法
	 * 1.声明一个没有实现的空方法
	 * 
	 */
	@Pointcut("execution(public int com.AAA.teng.impl.MyMathCalculator.*(..))")
	public void MyPoint(){};

    
	/**
	 * @throws Throwable 
	 * @Around:环绕：是Spring中最强大的通知；
	 * 动态代理
	 * try{
	 * 		//前置通知@Before
	 * 		method.invoke(obj,args);
	 * 		//返回通知@AfterReturning
	 * }catch(e){
	 * 		//异常通知@AfterThrowing
	 * }finally{
	 * 		//后置通知@After
	 * }
	 * 
	 * 四个通知合起来就是环绕通知
	 * 环绕通知中有一个参数
	 */
	@Around("MyPoint()")
	public Object myAround(ProceedingJoinPoint pjp) throws Throwable{
		
		Object[] args = pjp.getArgs();
		String name = pjp.getSignature().getName();

		Object proceed = null;
		try{
			System.out.println("环绕前置通知：【"+name+"】方法开始执行，用的参数列表【"+Arrays.asList(args)+"】");
			//利用反射调用目标方法即可，就是method.invoke(obj)
			proceed = pjp.proceed(args);			
			System.out.println("环绕返回通知：【"+name+"】方法执行完成，计算结果是："+proceed);
		}catch(Exception e){
			System.out.println("环绕异常通知：【"+name+"】方法执行出现异常，异常信息是："+e);
			//为了让外界知道这个异常，需要把异常抛出
			throw new RuntimeException(e);
		}finally{
			System.out.println("环绕后置通知：【"+name+"】方法执行结束！");
		}

		//反射调用后的返回值也一定返回出去
		return proceed;
	}
	

}
  • 环绕通知优先于普通通知执行

环绕通知

7). 多切面运行

多切面运行时执行顺序：默认按首字母排序，可以使用@Order(int)改变执行顺序;

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
@Aspect
@Component
//@Order(1)//使用order改变切面顺序
public class ValidateAspect {

	@Before("com.AAA.teng.utils.LogUtils.MyPoint()")
	public static void logStart(JoinPoint joinPoint){
		Object[] args = joinPoint.getArgs();
		Signature signature = joinPoint.getSignature();
		System.out.println("VaApsect前置:【"+signature.getName()+"】方法开始执行，用的参数列表【"+Arrays.asList(args)+"】");
	}

	@AfterReturning(value="com.AAA.teng.utils.LogUtils.MyPoint()",returning="result")
	public static void logReturn(JoinPoint joinPoint,Object result){
		Signature signature = joinPoint.getSignature();
		System.out.println("VaApsect返回:【"+signature.getName()+"】方法执行完成，计算结果是："+result);
	}
	
	@AfterThrowing(value="com.AAA.teng.utils.LogUtils.MyPoint()",throwing="e")
	public static void logException(JoinPoint joinPoint,Exception e){
		System.out.println("VaApsect异常:【"+joinPoint.getSignature().getName()+"】方法执行出现异常，异常信息是："+e);
	}
	
	@After("com.AAA.teng.utils.LogUtils.MyPoint()")
	public static void logEnd(JoinPoint joinPoint){
		System.out.println("VaApsect后置:【"+joinPoint.getSignature().getName()+"】方法执行结束！");
	}

}

jar包

五. xml配置AOP

正常情况下，基于注解的声明要优先于基于XML的声明。通过AspectJ注解，切面可以与AspectJ兼容，而基于XML的配置则是Spring专有的。

1). 方法类

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
public class LogUtils {

		
	public static void logStart(JoinPoint joinPoint){
		//获取到目标方法运行时使用的参数
		Object[] args = joinPoint.getArgs();
		//获取到方法签名
		Signature signature = joinPoint.getSignature();
		System.out.println("【"+signature.getName()+"】方法开始执行，用的参数列表【"+Arrays.asList(args)+"】");
	}
	public static void logReturn(JoinPoint joinPoint,Object result){
		//获取到方法签名
		Signature signature = joinPoint.getSignature();
		System.out.println("【"+signature.getName()+"】方法执行完成，计算结果是："+result);
	}
	
	public static void logException(JoinPoint joinPoint,Exception e){
		System.out.println("【"+joinPoint.getSignature().getName()+"】方法执行出现异常，异常信息是："+e);
	}
	
	public static void logEnd(JoinPoint joinPoint){
		System.out.println("【"+joinPoint.getSignature().getName()+"】方法执行结束！");
	}
	
	public Object myAround(ProceedingJoinPoint pjp) throws Throwable{
		
		Object[] args = pjp.getArgs();
		String name = pjp.getSignature().getName();

		Object proceed = null;
		try{
			System.out.println("环绕前置通知：【"+name+"】方法开始执行，用的参数列表【"+Arrays.asList(args)+"】");
			//利用反射调用目标方法即可，就是method.invoke(obj)
			proceed = pjp.proceed(args);			
			System.out.println("环绕返回通知：【"+name+"】方法执行完成，计算结果是："+proceed);
		}catch(Exception e){
			System.out.println("环绕异常通知：【"+name+"】方法执行出现异常，异常信息是："+e);
			//为了让外界知道这个异常，需要把异常抛出
			throw new RuntimeException(e);
		}finally{
			System.out.println("环绕后置通知：【"+name+"】方法执行结束！");
		}

		//反射调用后的返回值也一定返回出去
		return proceed;
	}	
}

2). 配置文件

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
44
45
46
47
48
49
50
51
52
53
54
55
56
	 <!-- 基于注解的AOP步骤:
	 	1.将目标类和切面类（封装了通知方法(在目标方法执行前后执行的方法)）加入到ioc容器中
	 	2.@Aspect标注切面类
	 	3.确定切面类中的方法什么时候运行
	 	4.开启基于注解的AOP功能
	 -->
	 
	 <!-- 基于配置的AOP功能 -->
	  <bean id="MyMathCalculator" class="com.AAA.teng.impl.MyMathCalculator"></bean>
	  <bean id="ValidateAspect" class="com.AAA.teng.utils.ValidateAspect"></bean>
	  <bean id="LogUtils" class="com.AAA.teng.utils.LogUtils"></bean>
	  <!-- 需要AOP名称空间 -->
	  <aop:config>
	  	<!-- 在外层设置可重用切入点 -->
	  	<aop:pointcut expression="execution(* com.AAA.teng.impl.MyMathCalculator.*(..))" id="globalpoint"/>

	  	<!-- 普通通知 === 目标方法 =【环绕执行返回,后置】= 普通后置 === 普通返回  -->
	  	<!-- 指定切面:@Aspect
	  			ref:切面类名
	  			order:切面类的执行顺序
	  	 -->
	  	<aop:aspect ref="LogUtils" order="2">
	  		<!-- 可重用的切入点表达式 -->
	  		<aop:pointcut expression="execution(* com.AAA.teng.impl.MyMathCalculator.*(..))" id="mypoint"/>
	  		<!-- 配置前置通知：
	  				method:指定方法名
	  				pointcut:切入点表达式
	  		 -->
	  		<aop:before method="logStart" pointcut="execution(* com.AAA.teng.impl.MyMathCalculator.*(..))"/>
	  		<!-- 配置返回通知
	  				returning:接收返回值
	  		 -->
	  		<aop:after-returning method="logReturn" pointcut-ref="mypoint" returning="result"/>
	  		<!-- 配置异常通知
	  				throwing:接收异常
	  		 -->
	  		<aop:after-throwing method="logException" pointcut-ref="mypoint" throwing="e"/>
	  		<!-- 配置后置通知 -->
	  		<aop:after method="logEnd" pointcut-ref="mypoint"/>
	  		<!-- 配置环绕通知（优先结束） -->
	  		<aop:around method="myAround" pointcut-ref="mypoint"/>	  		
	  	</aop:aspect>
	  	
	  	<aop:aspect ref="ValidateAspect" order="1">
	  		<aop:before method="logStart" pointcut="execution(* com.AAA.teng.impl.MyMathCalculator.*(..))"/>
	  		<aop:after-returning method="logReturn" pointcut-ref="globalpoint" returning="result"/>	  		
	  		<aop:after-throwing method="logException" pointcut-ref="globalpoint" throwing="e"/>
	  		<aop:after method="logEnd" pointcut-ref="globalpoint"/>	  		
	  	</aop:aspect>
	  </aop:config>
	  
	  <!-- 重要的用配置，不重要的用注解。
	  	注解：快速方便，简洁好用；
	  	配置：功能完善，便于修改；
	   -->
</beans>

3). xml配置和注解的区别：

  • 注解：快速方便，简洁好用；
  • 配置：功能完善，便于修改；

重要的用配置，不重要的用注解。

赏

感谢支持!

微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

正因为没有翅膀，<br>人们才会寻找飞翔的方法。