Spring-Aop两种代理方式：
1、JDK动态代理：用于目标类实现了接口；
2、Cglib动态代理：用于目标类没有实现接口；
spring会依据目标类是否实现接口来选择使用哪种代理方式（目标类：相当于需要被增强的类）；
模拟场景：目标类：步兵类，需要上战场打仗（手提精心打造的木棍）
通知类（增强类）：高级商店类，只要有士兵来就免费提供（精心打造的暴风大剑）
代理工厂类：需要一个士兵来使用商店的东西（这样才能把士兵与商店联系起来，士兵与商店本来是单独存在的相互不知道）
JDK动态代理实现：
创建maven项目引入spring-aop依赖，使用的是5.1版本
1、目标类需要实现接口，所以先创建一个接口：SoldierInterface(士兵类的接口)
package top.free;
/**
* 士兵接口
*/
public interface SoldierInterface {
public void begin();
}
2、创建目标类（步兵类去实现接口），也可以有其他的类（弓箭兵。。。）只要实现了士兵类，都是士兵。
package top.free;
/*
*步兵类
*/
public class Soldier implements SoldierInterface {
@Override
public void begin() {
System.out.println("弓箭士兵开始战斗");
}
}
3、通知（也叫增强）：商店类
package top.free.advice;
public class Store {
public void Before(){
System.out.println("为士兵换上暴风大剑。。。");
}
public void After(){
System.out.println("士兵胜利归来。。。");
}
}
4、创建代理工厂：需要传递过来一个士兵（不管是步兵还是弓箭兵），返回一个被商店加强的士兵
package top.free.proxy;
import top.free.SoldierInterface;
import top.free.advice.Store;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class MyProxyFactory {
//传递的soldier就是需要被增强的士兵类，
public SoldierInterface MyProxyFactory(SoldierInterface soldier){
//通知，此时的商店类，在工厂中new出的实列
Store store = new Store();
SoldierInterface proxysoldier = (SoldierInterface) Proxy.newProxyInstance(
MyProxyFactory.class.getClassLoader(),//第一个参数：使用当前类的类加载器
soldier.getClass().getInterfaces(),//第二个参数：传递的soldier士兵对象的接口
new InvocationHandler() {//第三个参数，匿名内部类形式
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//前置调用商店的配置
store.Before();
//调用目标方法，soldier就是传递的士兵对象，args参数默认无参
Object invoke = method.invoke(soldier, args);
//后置，士兵执行完方法后调用
store.After();
return invoke;
}
}
);
return proxysoldier;
}
}
5、测试运行：
package top.free;
import top.free.proxy.MyProxyFactory;
public class App
{
public static void main(String[] args) {
//创建工厂
MyProxyFactory myProxyFactory = new MyProxyFactory();
//创建目标类（士兵对象），具体的实现是步兵类
SoldierInterface soldier = new Soldier();
//将创建的士兵传递给工厂，工厂中有商店帮忙打造士兵，用新士兵接收
SoldierInterface newSoldier = myProxyFactory.MyProxyFactory(soldier);
//开始
newSoldier.begin();
}
}
Cglib动态代理实现：
写Jdk代理时已引入spring相关依赖，此时maven项目中已有spring-core包，Spring5.1版本中，spring-core包中有关于Cglib的类，不需要引入cglib依赖
1、Cglib代理使用的是没有接口的目标类，所以直接创建弓箭兵：
package top.free;
/**
* Cglib目标类,没有接口，弓箭兵类
*/
public class BowsSoldier {
public void begin(){
System.out.println("开始射杀敌人。。。");
}
}
2、通知（商店类）：
package top.free.advice;
public class Store {
public void Before(){
System.out.println("为士兵换上霸王弓。。。");
}
public void After(){
System.out.println("士兵胜利归来。。。");
}
}
3、创建代理工厂：需要一个弓箭兵，返回一个装备好的弓箭兵
package top.free.proxy;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import top.free.BowsSoldier;
import top.free.advice.Store;
import java.lang.reflect.Method;
public class MyCglibProxyFactory {
public BowsSoldier MyCglibProxyFactory(BowsSoldier solider){
//创建通知类
Store store = new Store();
//创建Enhance对象
Enhancer enhancer = new Enhancer();
//设置弓箭兵类对象
enhancer.setSuperclass(solider.getClass());
//设置回调方法
enhancer.setCallback(new MethodInterceptor() {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
//放在方法执行前，就是前置增强，装备弓箭
store.Before();
//执行方法，solider就是传递过来的弓箭兵对象
Object invoke = method.invoke(solider);
//后置增强
store.After();
return invoke;
}
});
//创建装备好的士兵
BowsSoldier target1= (BowsSoldier) enhancer.create();
return target1;
}
}
4、测试：
package top.free;
import top.free.proxy.MyCglibProxyFactory;
import top.free.proxy.MyProxyFactory;
public class App
{
public static void main(String[] args) {//创建代理工厂
MyCglibProxyFactory myCglibProxyFactory = new MyCglibProxyFactory();
//创建一个普通的弓箭兵
BowsSoldier soldier = new BowsSoldier();
//传递弓箭兵到工厂，工厂装备好后返回，接收一个装备精良的弓箭兵
BowsSoldier target = myCglibProxyFactory.MyCglibProxyFactory(soldier);
//装备精良的弓箭兵开始战斗
target.begin();
}
}
