Spring2-个人总结

Spring-第二章

Spring-AOP 代理，增强
目标类 + 额外功能 = 代理类
比如：日志处理/事务处理/异常处理/性能分析…Redis 非关系型数据

1. 通过spring AOP的代理功能，给代码增加额外的通用功能
2. 业务逻辑就专心的处理实际需求，通用的增强功能独立出来
3. 代理的专业术语
   额外功能叫 增强
   目标类叫 切入点 或 切面
   将增强 加入到 切入点，叫编织
   AOP是面向切面编程的一种实现

AOP步骤：

1. 导包
   

2. 书写一个增强类（前置为例）
   
   

3. 配置增强类的bean
   

4. 配置AOP的编织功能 写接口的包路径

1： 通配接口或者普通方法
2： 包名
3： 类名
4： 方法名
5： 参数

---

增强方式4种：

1. 前置增强，在核心功能之前执行的额外功能
   

2. 后置增强，在核心功能之后执行的额外功能
   

3. 异常增强，在核心功能发生异常时执行的额外功能
   

4. 环绕增强，在核心功能之前以及之后执行的额外功能
   

AOP实例 – 环绕增强日志记录
需求：记录商品的service层的日志操作，到数据库

1. 创建商品日志记录表 Product_Log
   

2. 完成日志记录表的插入逻辑

3. 环绕增强搜集日志记录参数，并测试

4. 环绕增强调用日志记录表的插入逻辑，完成日志记录功能
   注意：需要采用Spring IOC 模式，加载bean

AOP注解
可以灵活的定义哪个具体的方法实现增强功能

1. 写一个软 接口 创建或自定义一个注解
   @AnnotationLog
   

2. 增强类照常写

3. 修改切入点
   

个人总结

1. Spring-AOP 的定义
   AOP意为：面向切面编程，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的重要性，同时提高开发效率
   简单说就是：它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。
2. 什么是目标类，额外功能，代理类？
   Target(目标对象): 代理的目标对象。
   Advice(通知/增强): 所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。 通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。
   Proxy（代理）: 一个类被 AOP 织入增强后，就产生一个结果代理类。
3. 面向切面编程的定义
   在软件开发中，散布于应用中多处的功能被称为横切关注点。（cross-cutting concern）
   从概念上这些横切关注点，和应用的业务逻辑是相互分离的，但是实际中这些横切关注点却是直接嵌套在业务逻辑层中的。面向切面编程就是为了让这些关注点，和业务逻辑层分离。
4. Spring-AOP 的四种增强方式
   前置增强，后置增强，环绕增强，异常增强
5. Spring-AOP 注解增强方式
   package com.gxy.aop;

public @interface AnnotationLog {
//软接口
//只会把注解的方法进行增强，切入到面
}
@ AnnotationLog
6. Spring-AOP 示例 日志记录
package com.gxy.aop;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.gxy.service.ProductLogService;
import com.gxy.service.Impl.ProductLogServiceImpl;

public class MyInterceptor implements MethodInterceptor{

@Override
	public Object invoke(MethodInvocation arg0) throws Throwable {

// // TODO Auto-generated method stub
System.out.println(“this is interceptor 环绕增强”);
// //获取目标实现类对象
// System.out.println(“arg0.getThis()”+arg0.getThis());
// //获取目标方法名称
// System.out.println(“arg0.getMethod()”+arg0.getMethod());
// //获取目标方法参数的实参列表
// Object[] arguments = arg0.getArguments();
// for (int i = 0; i < arguments.length; i++) {
// System.out.println(“arg0.getArguments()”+arguments[i]);
// }
// //由于启动了环绕增强，目标类的方法将不再执行，而被，product取代，并返回目标类的反参，跳回核心方法
// //执行目标方法
// Object object = arg0.proceed();
// return object;
//日志记录功能//收集参数
//获取目标实现类对象
String actionClass = arg0.getThis().getClass().toString();
//获取目标方法名称
String methodName = arg0.getMethod().getName();
//拼接参数
String args="";
Object[] arguments = arg0.getArguments();
for (int i = 0; i < arguments.length; i++) {
System.out.println(“arg0.getArguments()”+arguments[i]);
args = args+"-"+arguments[i];
}

	//删除第一个多余连接符
	args = args.replaceFirst("-", "");
	//调用ProductLogService的业务逻辑
	//进行加载Spring配置文件，生成工厂
	ApplicationContext Context = new ClassPathXmlApplicationContext("applicationContext.xml");
	//根据bean ID，由工厂创建对象
	ProductLogService productLogService = (ProductLogService) Context.getBean("ProductLogService");
	ProductLogService productLog = new ProductLogServiceImpl();
	int i = productLog.addLog(actionClass, methodName, args);
	System.out.println(i);
	//执行原来的方法
	Object object = arg0.proceed();
return object;
}

}

总结
就我来说
AOP作为springMVC最常用的功能之一，就好像A和B两个业务员一般，如果A想用B的代码，就需要不停的调用，比较繁琐与复杂，但是我们经过进行代理，交给第三方进行管理与维护，大大减少其维护的工作量，实现啦很好的解耦合