Spring系列五：手动实现Spring底层机制 第三部分

💗实现任务阶段5

🍚bean后置处理器实现

bean后置处理器实现

思路:先完成原生Spring 使用Bean后置处理器的案例, 然后实现自己的bean后置处理器

bean的生命周期~传送门

在idea中 shortcuts: shift+shift , 输入 InitializingBean, 搜索. 在zzw-spring项目里

1.在com.zzw.spring.processor包下定义接口 InitializingBean. 实现该接口的Bean, 需要实现Bean初始化方法, 可以参考 原生Spring规范来定义这个接口👆

//解读
//1.我们根据原生Spring 定义了一个InitializingBean
//2.这个接口有一个方法 void afterPropertiesSet() throws Exception;
//3.afterPropertiesSet() 在Bean的 setter后执行, 即就是我们原来的初始化方法
//4.当一个Bean实现这个接口后, 就实现这个afterPropertiesSet(), 这个方法就是初始化方法
public interface InitializingBean {void afterPropertiesSet() throws Exception;
}

2.MonsterService 实现这个接口

@Component(value = "monsterService")// 把MonsterService注入我们自己写的spring容器中
@Scope(value = "prototype")
public class MonsterService implements InitializingBean {@Autowiredprivate MonsterDao monsterDao;public void m1() {monsterDao.hi();}/*** 解读* 1.afterPropertiesSet就是在bean的setter方法执行完毕后被spring容器调用* 2.即就是初始化方法* @throws Exception*/@Overridepublic void afterPropertiesSet() throws Exception {System.out.println("MonsterService 初始化方法被调用 程序员在这里加入初始化的业务...");}
}

说明
在创建好Bean实例后, 判断是否需要进行初始化. 【编程心得: 容器中常用的一个方法是, 根据该类是否实现了某个接口, 来判断是否要执行某个业务逻辑, 这里其实就是java基础的接口编程实际应用】

1.在ZzwSpringApplicationContext类的createBean方法遍历字段后加入如下代码

System.out.println("======创建好实例======" + instance);
//这里判断是否要执行Bean的初始化方法
//1.判断当前创建的Bean对象是否实现了InitializingBean接口
//2.instanceof 表示判断某个对象的运行类型是不是某个类型或其子类型
//3.这里使用到接口编程
if (instance instanceof InitializingBean) {//将instance转成接口InitializingBean((InitializingBean) instance).afterPropertiesSet();
}
return instance;

2.注销ZzwSpringApplicationContext类的构造器中的下面两条代码

//System.out.println("singletonObjects 单例池=" + singletonObjects);
//System.out.println("beanDefinitionMap=" + beanDefinitionMap);

3.测试com.zzw.spring.AppMain

public class AppMain {public static void main(String[] args) {ZzwSpringApplicationContext ioc =new ZzwSpringApplicationContext(ZzwSpringConfig.class);MonsterService monsterService = (MonsterService)ioc.getBean("monsterService");}
}

4.运行效果

//上面输出结果忽略...
======创建好实例======com.zzw.spring.component.MonsterDao@5479e3f
======创建好实例======com.zzw.spring.component.MonsterService@33e5ccce
MonsterService 初始化方法被调用 程序员在这里加入初始化的业务...

5.MonsterDao实现InitializingBean的方法

@Component(value = "monsterDao")
//@Scope(value = "prototype")
public class MonsterDao implements InitializingBean {public void hi() {System.out.println("MonsterDao hi()...");}@Overridepublic void afterPropertiesSet() throws Exception {System.out.println("MonsterDao 初始化方法被调用...");}
}

6.测试com.zzw.spring.AppMain

public class AppMain {public static void main(String[] args) {ZzwSpringApplicationContext ioc =new ZzwSpringApplicationContext(ZzwSpringConfig.class);MonsterService monsterService = (MonsterService)ioc.getBean("monsterService");}
}

7.运行效果

上面输出结果忽略...
======创建好实例======com.zzw.spring.component.MonsterDao@27082746
MonsterDao 初始化方法被调用...
======创建好实例======com.zzw.spring.component.MonsterService@33e5ccce
MonsterService 初始化方法被调用 程序员在这里加入初始化的业务...

8.参考原生Spring容器的BeanPostProcessor接口, 定义com.zzw.spring.processor.BeanPostProcessor接口
注意: 在jdk8及jdk8以后, 接口中可以有默认实现方法, 需要是由default关键字修饰

//解读
//1.参考原生Spring容器定义一个接口BeanPostProcessor
//2.该接口有两个方法postProcessBeforeInitialization 和 postProcessAfterInitialization
//3.这两个方法, 会对Spring容器的所有Bean生效, 已经是切面编程的概念
public interface BeanPostProcessor {/*** 说明* 1.postProcessBeforeInitialization在Bean的初始化方法前调用* @param bean* @param beanName* @return*/default Object postProcessBeforeInitialization(Object bean, String beanName) {return bean;}/*** 1.postProcessAfterInitialization在Bean的初始化方法后调用* @param bean* @param beanName* @return*/default Object postProcessAfterInitialization(Object bean, String beanName) {return bean;}
}

9.在com.zzw.spring.component包下新建ZzwBeanPostProcessor

/*** 说明* 1.这是我们自己的一个后置处理器* 2.实现了BeanPostProcessor* 3.我们可以重写before和after方法* 4.在Spring容器中, 仍然把ZzwBeanPostProcessor当做一个Bean对象, 要注入到容器* 5.@Component 标识* 6.我们要让ZzwBeanPostProcessor成为真正的后置处理器, 需要在容器中加入业务代码* 7.还要考虑多个后置处理器对象注入到容器的问题
*/
@Component
public class ZzwBeanPostProcessor implements BeanPostProcessor {@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) {System.out.println("后置处理器ZzwBeanPostProcessor Before方法 被调用... bean类型="+ bean.getClass() + " bean的名字=" + beanName);return bean;}@Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) {System.out.println("后置处理器ZzwBeanPostProcessor After方法 被调用... bean类型="+ bean.getClass() + " bean的名字=" + beanName);return bean;}
}

这时后置处理器不会生效, 继续写代码支撑.

10.在ZzwSpringApplicationContext类中定义一个属性, 在beanDefinitionsByScan方法中添加代码

//代码省略...//定义一个属性beanPostProcessorList, => 存放后置处理器
private List<BeanPostProcessor> beanPostProcessorList= new ArrayList<>();//代码省略...public void beanDefinitionsByScan(Class configClass) {//代码省略...try {Class<?> clazz = classLoader.loadClass(classFullName);//这里就是演示了一下机制if (clazz.isAnnotationPresent(Component.class)) {//如果该类使用了@Component注解, 说明是Spring beanSystem.out.println("是一个Spring bean=" + clazz + " 类名=" + className);//说明👇//1.为了方便, 这里将后置处理器放入到一个ArrayList//2.如果发现是一个后置处理器, 就放入到beanPostProcessorList//3.在原生的Spring容器中, 对后置处理器还是走的getBean(),createBean()//  ,但是需要我们在singletonObjects中加入相应的业务逻辑//4.因为这里我们只是为了学习后置处理器的机制, 就简化处理.//5.如果仍然走以前的逻辑, 也可以, 就是要麻烦一点.//判断当前这个clazz有没有实现我们定义的BeanPostProcessor接口//说明, 这里我们不能用 instanceof 来判断clazz是否实现了BeanPostProcessor接口//原因: clazz不是一个实例对象, 而是一个类对象/clazz, 使用isAssignableFrom// 将其当作一个语法理解if (BeanPostProcessor.class.isAssignableFrom(clazz)) {BeanPostProcessor beanPostProcessor= (BeanPostProcessor) clazz.newInstance();//将其放入到BeanPostProcessorListbeanPostProcessorList.add(beanPostProcessor);}👆//代码省略...} else {//如果该类没有使用@Component注解, 说明不是Spring beanSystem.out.println("不是一个Spring bean=" + clazz + " 类名=" + className);}} catch (Exception e) {throw new RuntimeException(e);}
}

11.在ZzwSpringApplicationContext类的createBean方法中添加如下代码

 System.out.println("======创建好实例======" + instance);👇//我们在Bean的初始化方法前, 调用后置处理器的before方法for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {//在后置处理器的before方法, 可以对容器bean进行处理//然后返回处理后的bean实例, 相当于做了一个前置处理instance =beanPostProcessor.postProcessBeforeInitialization(instance, "...");
👆}//这里判断是否要执行Bean的初始化方法//1.判断当前创建的Bean对象是否实现了InitializingBean接口//2.instanceof 表示判断某个对象的运行类型是不是某个类型或者某个类型的子类型//3.这里使用到接口编程if (instance instanceof InitializingBean) {//3.将instance转成接口InitializingBean((InitializingBean) instance).afterPropertiesSet();}👇//我们在Bean的初始化方法后, 调用后置处理器的after方法for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {//在后置处理器的after方法, 可以对容器bean进行处理//然后返回处理后的bean实例, 相当于做了一个后置处理instance =beanPostProcessor.postProcessAfterInitialization(instance, "...");
👆}return instance;

12.测试com.zzw.spring.AppMain

public class AppMain {public static void main(String[] args) {ZzwSpringApplicationContext ioc =new ZzwSpringApplicationContext(ZzwSpringConfig.class);MonsterService monsterService = (MonsterService)ioc.getBean("monsterService");}
}

13.运行结果

//前面输出结果忽略...
======创建好实例======com.zzw.spring.component.ZzwBeanPostProcessor@4c75cab9
后置处理器ZzwBeanPostProcessor Before方法 被调用... bean类型=class com.zzw.spring.component.ZzwBeanPostProcessor bean的名字=...
后置处理器ZzwBeanPostProcessor After方法 被调用... bean类型=class com.zzw.spring.component.ZzwBeanPostProcessor bean的名字=...
======创建好实例======com.zzw.spring.component.MonsterDao@67117f44
后置处理器ZzwBeanPostProcessor Before方法 被调用... bean类型=class com.zzw.spring.component.MonsterDao bean的名字=...
MonsterDao 初始化方法被调用...
后置处理器ZzwBeanPostProcessor After方法 被调用... bean类型=class com.zzw.spring.component.MonsterDao bean的名字=...
======创建好实例======com.zzw.spring.component.MonsterService@3930015a
后置处理器ZzwBeanPostProcessor Before方法 被调用... bean类型=class com.zzw.spring.component.MonsterService bean的名字=...
MonsterService 初始化方法被调用 程序员在这里加入初始化的业务...
后置处理器ZzwBeanPostProcessor After方法 被调用... bean类型=class com.zzw.spring.component.MonsterService bean的名字=...

这里有两份ZzwBeanPostProcessor, 去掉singletonObjects中的后置处理器对象, 保留beanPostProcessorList中的, 因为我们自定义的beanPostProcessorList操作起来方便.

1.在ZzwSpringApplicationContext的beanDefinitionsByScan方法内添加continue跳过循环

if (BeanPostProcessor.class.isAssignableFrom(clazz)) {BeanPostProcessor beanPostProcessor= (BeanPostProcessor) clazz.newInstance();//将其放入到BeanPostProcessorListbeanPostProcessorList.add(beanPostProcessor);👉continue;👈
}

2.测试com.zzw.spring.AppMain

public class AppMain {public static void main(String[] args) {ZzwSpringApplicationContext ioc =new ZzwSpringApplicationContext(ZzwSpringConfig.class);MonsterService monsterService = (MonsterService)ioc.getBean("monsterService");}
}

3.运行结果

//前面输出结果忽略...
======创建好实例======com.zzw.spring.component.MonsterDao@7bfcd12c
后置处理器ZzwBeanPostProcessor Before方法 被调用... bean类型=class com.zzw.spring.component.MonsterDao bean的名字=...
MonsterDao 初始化方法被调用...
后置处理器ZzwBeanPostProcessor After方法 被调用... bean类型=class com.zzw.spring.component.MonsterDao bean的名字=...
======创建好实例======com.zzw.spring.component.MonsterService@1ef7fe8e
后置处理器ZzwBeanPostProcessor Before方法 被调用... bean类型=class com.zzw.spring.component.MonsterService bean的名字=...
MonsterService 初始化方法被调用 程序员在这里加入初始化的业务...
后置处理器ZzwBeanPostProcessor After方法 被调用... bean类型=class com.zzw.spring.component.MonsterService bean的名字=...

1.新建com.zzw.spring.component.Car.让Car类实现InitializingBean初始化方法

@Component
public class Car implements InitializingBean {@Overridepublic void afterPropertiesSet() throws Exception {System.out.println("Car的初始化方法...");}
}

2.测试com.zzw.spring.AppMain

public class AppMain {public static void main(String[] args) {ZzwSpringApplicationContext ioc =new ZzwSpringApplicationContext(ZzwSpringConfig.class);MonsterService monsterService = (MonsterService)ioc.getBean("monsterService");}
}

3.运行结果

//前面输出结果忽略...
======创建好实例======com.zzw.spring.component.Car@6f79caec
后置处理器ZzwBeanPostProcessor Before方法 被调用... bean类型=class com.zzw.spring.component.Car bean的名字=...
Car的初始化方法...
后置处理器ZzwBeanPostProcessor After方法 被调用... bean类型=class com.zzw.spring.component.Car bean的名字=...
======创建好实例======com.zzw.spring.component.MonsterDao@5d3411d
后置处理器ZzwBeanPostProcessor Before方法 被调用... bean类型=class com.zzw.spring.component.MonsterDao bean的名字=...
MonsterDao 初始化方法被调用...
后置处理器ZzwBeanPostProcessor After方法 被调用... bean类型=class com.zzw.spring.component.MonsterDao bean的名字=...
======创建好实例======com.zzw.spring.component.MonsterService@50675690
后置处理器ZzwBeanPostProcessor Before方法 被调用... bean类型=class com.zzw.spring.component.MonsterService bean的名字=...
MonsterService 初始化方法被调用 程序员在这里加入初始化的业务...
后置处理器ZzwBeanPostProcessor After方法 被调用... bean类型=class com.zzw.spring.component.MonsterService bean的名字=...

4.修改com.zzw.spring.processor.ZzwBeanPostProcessor的before方法

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) {//这里一定要体会到后置处理器是对容器创建的所有bean生效//, 相当于是可以对多个对象编程, 切面编程//日志, 权限, 身份, 事务...if (bean instanceof Car) {System.out.println("这是一个Car对象, 我可以处理");//((Car) bean)}System.out.println("后置处理器ZzwBeanPostProcessor Before方法 被调用... bean类型="+ bean.getClass() + " bean的名字=" + beanName);return bean;
}

5.测试com.zzw.spring.AppMain

public class AppMain {public static void main(String[] args) {ZzwSpringApplicationContext ioc =new ZzwSpringApplicationContext(ZzwSpringConfig.class);MonsterService monsterService = (MonsterService)ioc.getBean("monsterService");}
}

6.运行结果

//前面输出结果忽略...
======创建好实例======com.zzw.spring.component.Car@6f79caec
这是一个Car对象, 我可以处理
后置处理器ZzwBeanPostProcessor Before方法 被调用... bean类型=class com.zzw.spring.component.Car bean的名字=...
Car的初始化方法...
后置处理器ZzwBeanPostProcessor After方法 被调用... bean类型=class com.zzw.spring.component.Car bean的名字=...
======创建好实例======com.zzw.spring.component.MonsterDao@5d3411d
后置处理器ZzwBeanPostProcessor Before方法 被调用... bean类型=class com.zzw.spring.component.MonsterDao bean的名字=...
MonsterDao 初始化方法被调用...
后置处理器ZzwBeanPostProcessor After方法 被调用... bean类型=class com.zzw.spring.component.MonsterDao bean的名字=...
======创建好实例======com.zzw.spring.component.MonsterService@50675690
后置处理器ZzwBeanPostProcessor Before方法 被调用... bean类型=class com.zzw.spring.component.MonsterService bean的名字=...
MonsterService 初始化方法被调用 程序员在这里加入初始化的业务...
后置处理器ZzwBeanPostProcessor After方法 被调用... bean类型=class com.zzw.spring.component.MonsterService bean的名字=...

完善: 对下列代码的beanName进行完善.

instance = beanPostProcessor.postProcessBeforeInitialization(instance, "...");

1.ZzwSpringApplicationContext类的createBean方法增加一个形参String beanName

private Object createBean(BeanDefinition beanDefinition, 👉String beanName👈) {//内容忽略...//我们在Bean的初始化方法前, 调用后置处理器的before方法for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {//在后置处理器的before方法, 可以对容器bean进行处理//然后返回处理后的bean实例, 相当于做了一个前置处理instance =beanPostProcessor.postProcessBeforeInitialization(instance, 👉beanName👈);}//我们在Bean的初始化方法后, 调用后置处理器的after方法for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {//在后置处理器的after方法, 可以对容器bean进行处理//然后返回处理后的bean实例, 相当于做了一个后置处理instance =beanPostProcessor.postProcessAfterInitialization(instance, 👉beanName👈);}
}

2.修改ZzwSpringApplicationContext类的getBean方法

//编写方法getBean(String name), 编写方法返回容器对象
public Object getBean(String name) {//加一个判断条件: 传入的beanName是否在beanDefinitionMap中存在if (beanDefinitionMap.containsKey(name)) {//如果存在BeanDefinition beanDefinition = beanDefinitionMap.get(name);//得到beanDefinition的scope, 分别进行处理if ("singleton".equalsIgnoreCase(beanDefinition.getScope())) {//说明是单例配置, 就直接从单例池获取return singletonObjects.get(name);} else {//如果不是单例的, 我们就调用createBean, 反射一个对象返回return createBean(beanDefinition, 👉name👈);}} else {//如果不存在//抛出一个空指针异常, 也可以自定义throw new NullPointerException("没有该bean");}
}

3.修改ZzwSpringApplicationContext类的构造器方法

//构造器
public ZzwSpringApplicationContext(Class configClass) {//完成扫描指定的包beanDefinitionsByScan(configClass);//通过beanDefinitionMap, 初始化singletonObjects 单例池//封装成方法//遍历所有的beanDefinition对象Enumeration<String> keys = beanDefinitionMap.keys();while (keys.hasMoreElements()) {//得到beanName, 得到对应的beanDefinitionString beanName = keys.nextElement();BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);//判断该bean是singleton, 还是prototypeif ("singleton".equals(beanDefinition.getScope())) {//将该bean实例放入到singletonObjects 集合Object bean = createBean(beanDefinition, 👉beanName👈);singletonObjects.put(beanName, bean);}}
}

4.测试com.zzw.spring.AppMain

public class AppMain {public static void main(String[] args) {ZzwSpringApplicationContext ioc =new ZzwSpringApplicationContext(ZzwSpringConfig.class);MonsterService monsterService = (MonsterService)ioc.getBean("monsterService");}
}

5.运行结果

//前面输出结果忽略...
======创建好实例======com.zzw.spring.component.Car@6f79caec
这是一个Car对象, 我可以处理
后置处理器ZzwBeanPostProcessor Before方法 被调用... bean类型=class com.zzw.spring.component.Car bean的名字=car
Car的初始化方法...
后置处理器ZzwBeanPostProcessor After方法 被调用... bean类型=class com.zzw.spring.component.Car bean的名字=car
======创建好实例======com.zzw.spring.component.MonsterDao@5d3411d
后置处理器ZzwBeanPostProcessor Before方法 被调用... bean类型=class com.zzw.spring.component.MonsterDao bean的名字=monsterDao
MonsterDao 初始化方法被调用...
后置处理器ZzwBeanPostProcessor After方法 被调用... bean类型=class com.zzw.spring.component.MonsterDao bean的名字=monsterDao
======创建好实例======com.zzw.spring.component.MonsterService@50675690
后置处理器ZzwBeanPostProcessor Before方法 被调用... bean类型=class com.zzw.spring.component.MonsterService bean的名字=monsterService
MonsterService 初始化方法被调用 程序员在这里加入初始化的业务...
后置处理器ZzwBeanPostProcessor After方法 被调用... bean类型=class com.zzw.spring.component.MonsterService bean的名字=monsterService

@Component
public class ZzwBeanPostProcessor implements BeanPostProcessor {@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) {//这里一定要体会到后置处理器是对容器创建的所有bean生效//相当于可以对多个对象编程, 切面编程//日志, 权限, 身份, 事务.if (bean instanceof Car) {System.out.println("这是一个Car对象, 我可以处理");}System.out.println("后置处理器ZzwBeanPostProcessor Before方法被调用 beand对象=" + bean+ " bean名字=" + beanName);return null;}@Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) {System.out.println("后置处理器ZzwBeanPostProcessor After方法被调用 beand对象=" + bean+ " bean名字=" + beanName);return null;}
}

//我们在Bean的初始化方法前, 调用后置处理器的before方法
for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {//在后置处理器的before方法, 可以对容器bean进行处理//然后返回处理后的bean实例, 相当于做了一个前置处理👇Object current =beanPostProcessor.postProcessBeforeInitialization(instance, beanName);if (current != null) {instance = current;👆}
}//这里判断是否要执行Bean的初始化方法
//1.判断当前创建的Bean对象是否实现了InitializingBean接口
//2.instanceof 表示判断某个对象的运行类型是不是某个类型或者某个类型的子类型
//3.这里使用到接口编程
if (instance instanceof InitializingBean) {//3.将instance转成接口InitializingBean((InitializingBean) instance).afterPropertiesSet();
}//我们在Bean的初始化方法后, 调用后置处理器的after方法
for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {//在后置处理器的after方法, 可以对容器bean进行处理//然后返回处理后的bean实例, 相当于做了一个后置处理// 原生Spring容器, 比我们这个还要复杂👇Object current =beanPostProcessor.postProcessAfterInitialization(instance, beanName);if (current != null) {instance = current;👆}
}

public class AppMain {public static void main(String[] args) {ZzwSpringApplicationContext ioc =new ZzwSpringApplicationContext(ZzwSpringConfig.class);MonsterService monsterService = (MonsterService)ioc.getBean("monsterService");}
}

public interface SmartAnimalAble {float getSum(float i, float j);float getSub(float i, float j);
}

@Component(value = "smartDog")
public class SmartDog implements SmartAnimalAble{public float getSum(float i, float j) {float res = i + j;System.out.println("SmartDog getSum() 结果=" + res);return res;}public float getSub(float i, float j) {float res = i - j;System.out.println("SmartDog getSub() 结果=" + res);return res;}
}

//说明: SmartAnimalAspect当做一个切面类来使用
//,后面再分析如何做得更加灵活
public class SmartAnimalAspect {public static void showBeginLog() {System.out.println("前置通知..");}public static void showSuccessEndLog() {System.out.println("返回通知..");}
}

@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {System.out.println("后置处理器ZzwBeanPostProcessor After方法 被调用... bean类型="+ bean.getClass() + " bean的名字=" + beanName);//实现AOP, 返回代理对象, 即对Bean进行包装//1.先死后活 -> 后面我们可以通过注解就可以更加灵活if ("smartDog".equals(beanName)) {//使用Jdk的动态代理, 返回该bean的代理对象Object proxyInstance = Proxy.newProxyInstance(ZzwBeanPostProcessor.class.getClassLoader(),bean.getClass().getInterfaces(), new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("method=" + method.getName());Object result = null;//假如我们要进行前置通知+返回通知处理的方法是getSum// 后面可以通过注解来做的更加灵活@Before @AfterReturningif ("getSum".equals(method.getName())) {SmartAnimalAspect.showBeginLog();result = method.invoke(bean, args);//执行目标方法//进行返回通知的处理SmartAnimalAspect.showSuccessEndLog();} else {result = method.invoke(bean, args);//执行目标方法}return result;}});//如果bean是需要返回代理对象的, 这里就直接return proxyInstancereturn proxyInstance;}//如果不需要AOP, 返回 beanreturn bean;
}

public class AppMain {public static void main(String[] args) {//创建自己的容器ZzwSpringApplicationContext ioc =new ZzwSpringApplicationContext(ZzwSpringConfig.class);SmartAnimalAble smartDog = (SmartAnimalAble) ioc.getBean("smartDog");smartDog.getSum(10, 2);smartDog.getSub(10, 2);System.out.println("ok");}
}

//前面输出结果省略...
method=getSum
前置通知..
SmartDog getSum() 结果=12.0
返回通知..
method=getSub
SmartDog getSub() 结果=8.0
//后面输出结果省略...

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface Aspect {String value() default "";
}

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Before {String value();String argNames() default "";
}

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface AfterReturning {String value() default "";String pointcut() default "";String returning() default "";String argNames() default "";
}

@Aspect //我们自己的注解
@Component //我们自己的注解
public class SmartAnimalAspect {@Before(value = "execution com.zzw.spring.component.SmartDog getSum")public static void showBeginLog() {System.out.println("前置通知..");}@AfterReturning(value = "execution com.zzw.spring.component.SmartDog getSum")public static void showSuccessEndLog() {System.out.println("返回通知..");}
}

public class ZzwTest {public static void main(String[] args) throws NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {//1.获取SmartAnimalAspect的class对象Class<SmartAnimalAspect> clazz = SmartAnimalAspect.class;//2.遍历该类的所有方法for (Method declaredMethod : clazz.getDeclaredMethods()) {//如果切面类的方法有Before注解if (declaredMethod.isAnnotationPresent(Before.class)) {//得到切面类的切入方法System.out.println("method名字=" + declaredMethod.getName());//得到Before注解Before beforeAnnotation = declaredMethod.getDeclaredAnnotation(Before.class);//得到Before注解 的valueString value = beforeAnnotation.value();System.out.println("value=" + value);//得到要切入的方法[通过反射调用]Method declaredMethod1 = clazz.getDeclaredMethod(declaredMethod.getName());//调用切入方法declaredMethod1.invoke(clazz.newInstance(), null);} else if (declaredMethod.isAnnotationPresent(AfterReturning.class)) {//如果切面类的方法有AfterReturning注解, 同样可以进行类似处理//得到切面类的切入方法System.out.println("method名字=" + declaredMethod.getName());//得到AfterReturning注解AfterReturning afterReturningAnnotation = declaredMethod.getAnnotation(AfterReturning.class);//得到AfterReturning注解 的valueString value = afterReturningAnnotation.value();System.out.println("value=" + value);//得到要切入的方法Method declaredMethod1 = clazz.getDeclaredMethod(declaredMethod.getName());//调用切入方法[通过反射调用]declaredMethod1.invoke(clazz.newInstance(), null);}}}
}

method名字=showBeginLog
value=execution com.zzw.spring.component.SmartDog getSum
前置通知..
method名字=showSuccessEndLog
value=execution com.zzw.spring.component.SmartDog getSum
返回通知..