动态代理
一、什么是动态代理
动态代理就是，在程序运行期，创建目标对象的代理对象，并对目标对象中的方法进行功能性增强的一种技术。在生成代理对象的过程中，目标对象不变，代理对象中的方法是目标对象方法的增强方法。可以理解为运行期间，对象中方法的动态拦截，在拦截方法的前后执行功能操作。
代理类在程序运行期间，创建的代理对象称之为动态代理对象。这种情况下，创建的代理对象，并不是事先在Java代码中定义好的。而是在运行期间，根据我们在动态代理对象中的“指示”，动态生成的。也就是说，你想获取哪个对象的代理，动态代理就会为你动态的生成这个对象的代理对象。动态代理可以对被代理对象的方法进行功能增强。有了动态代理的技术，那么就可以在不修改方法源码的情况下，增强被代理对象的方法的功能，在方法执行前后做任何你想做的事情。
二、动态代理的使用
动态代理有两种常用的方式：
1. 基于接口的动态代理：
提供者：JDK
使用JDK官方的Proxy类创建代理对象
注意：代理的目标对象必须实现接口
2. 基于类的动态代理：
提供者：第三方的CGLib
使用CGLib的Enhancer类创建代理对象
注意：如果报asmxxxx异常，需要导入asm.jar包
基于接口的动态代理，实现步骤如下：
1、因为Proxy类必须基于接口进行动态代理，所以首先创建接口，定义接口的规范，即功能方法的定义。
public interface Actor {
void sing();
void dance();
void rap();
}2、定义实现接口的子类，实现接口定义的方法，此方法只需要把核心功能实现即可，其他增强的操作可以在代理类中实现。
public class Cxk implements Actor {
@Override
public void sing() {
System.out.println("cxk在唱鸡你太美");
}
@Override
public void dance() {
System.out.println("ckx在跳篮球舞");
}
@Override
public void rap() {
System.out.println("cxk在rap Hi");
}
}3、定义代理类，在代理类中对被代理对象进行方法增强。
public class JJR {
public static void main(String[] args) {
//1.定义被代理类
Actor cxk = new Cxk();
/**
* 2.创建代理对象
* 参数：
* ClassLoader loader：被代理的类的加载器(我要代理谁)
* Class<?>[] interfaces：被代理对象的接口(我要代理的对象继承了哪个接口，就知道代理对象可以完成哪些功能)
* InvocationHandler h：执行代理(代理之后我要做什么？)
*/
Actor jjr = (Actor) Proxy.newProxyInstance(Cxk.class.getClassLoader(), Cxk.class.getInterfaces(), new InvocationHandler() {
/**
* invoke方法就是执行代理操作，参数：
* proxy：代理对象的引用。不一定每次都用得到
* method：当前执行的方法对象
* args：执行方法所需的参数
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//前置增强
System.out.println("前置通知/增强");
//获取方法三要数：方法名、参数、返回值
Object result = null;//定义代理对象执行方法的返回值
String methodName = method.getName();//代理对象执行的方法
System.out.println("当前被执行的方法是："+methodName);
result = method.invoke(cxk, args);//执行被代理对象的方法
//后置增强操作
System.out.println("后置通知/增强");
return result;
}
});
//有代理对象执行方法的时候不再是被代理对象执行方法，而是由我们的代理类对象执行方法
jjr.sing();
}
}Spring AOP
一、概述
AOP---面向切片编程（Aspect Oriented Programming）可以说是对OOP（面向对象编程）的补充和完善，面向对象就是将事物的特性和行为抽象为一个对象，如people类有身高、体重、年龄等属性，也有吃饭、睡觉等行为。把这些特性和行为封装成一个类，然后可以统一调用。面向切片也可以举个例子，比如people类有自己的属性和行为，但是有小一部分人生病要去医院看病，看病这个业务逻辑就不属于哪一个类，因为people泛指所有人，所有人不会都看病。AOP就是把医院看病这一个业务逻辑功能抽取出来，然后动态把这个功能切入到需要的方法（或行为）中，需要的才切入，这样便于减少系统的重复代码，降低模块间的耦合度。常用到AOP的就是安全校验、日志操作、事务操作等，给你先定义好，然后在想用的地方用，这样不会影响已经在服务器运行的项目，然后又能注入新功能，灵活。
通俗描述：不通过修改源代码的方式，在主干功能里面添加新功能
二、AOP中的相关概念
- Joinpoint(连接点)：所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。
- Pointcut(切入点)：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。
- Advice(通知/增强)：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。
- Introduction(引介)：引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。
- Target(目标对象)：代理的目标对象。
- Weaving(织入)：是指把增强应用到目标对象来创建新的代理对象的过程。spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。
- Proxy(代理)：一个类被 AOP 织入增强后，就产生一个结果代理类。
- Aspect(切面)：是切入点和通知（引介）的结合。
三、AOP基于XML配置的入门案例
1.首先导入IOC和AOP所需的jar包
2.创建BookService接口，这个接口用来定义核心功能操作的抽象方法。
public interface BookServive {
void findAll();
void save(int a);
int del();
void update();
}3.创建BookServiceImpl类，这个类用来实现BookService接口完成核心功能操作。
public class BookServiceImpl implements BookServive {
@Override
public void findAll() {
System.out.println("查询所有");
}
@Override
public void save(int a) {
System.out.println("保存信息"+"---"+a);
}
@Override
public int del() {
System.out.println("删除信息");
int i=1/0;
return i;
}
@Override
public void update() {
System.out.println("修改信息");
}
}4.创建Logger类，这个类是用来做功能的增强。
public class logger {
public void check() {
System.out.println("前置通知/增强：权限验证");
}
public void logPrint() {
System.out.println("后置通知/增强：日志输出");
}
public void exceptio() {
System.out.println("异常通知/增强：异常处理");
}
public void distroy() {
System.out.println("最终通知/增强：资源释放");
}
}5.在src下创建xml文件进行AOP的配置
<?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 http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 1.把所有类的对象交给IOC容器进行管理-->
<bean id="logger" class="com.dou.logger.logger"/>
<bean id="bookService" class="com.dou.service.impl.BookServiceImpl"/>
<!-- 2.AOP的配置：让增强类 的 哪个方法 动态进行何种增强-->
<aop:config>
<!-- 指定增强类并起名-->
<aop:aspect id="log" ref="logger">
<!-- 在标签的内部使用对应标签来配置通知的类型(用增强类的哪个方法对核心类的哪个方法进行增强) -->
<!--
method：增强类的方法
pointcut：是一个表达式，用来标明要增强哪个类的哪个方法
-->
<!-- aop:before：前置通知/增强：在核心类方法执行之前 进行 增强 -->
<aop:before method="check" pointcut="execution(void com.dou.service.impl.BookServiceImpl.findAll())"/>
<aop:after-returning method="logPrint" pointcut="execution(void com.dou.service.impl.BookServiceImpl.save(int))"/>
<aop:after-throwing method="exceptio" pointcut="execution(int *..BookServiceImpl.del())"/>
<aop:after method="distroy" pointcut="execution(void com.dou.service.impl.BookServiceImpl.update())"/>
</aop:aspect>
</aop:config>
</beans>6.测试类
public class Test01 {
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
BookServive bookServive = context.getBean(BookServive.class);
bookServive.findAll();
System.out.println("---------------------------");
bookServive.save(1);
System.out.println("---------------------------");
int del = bookServive.del();
System.out.println(del);
System.out.println("---------------------------");
bookServive.update();
}
}