Spring AOP实现（3）

作者: 低调的灬攻城狮 | 来源:发表于2020-03-01 21:21 被阅读0次

Spring AOP源码02 - 代理的创建
spring-aop
Spring之AOP面向切面编程
Spring Aop、拦截器、过滤器的区别
Spring
[java][SpringAOP]
Spring AOP 实现原理
Spring（3）——AOP
Spring一般切面
Spring 学习－－AOP

第六种方式

自动代理
IUserService.java

public interface IUserService {
    /**
     * 获取所有的用户对象列表
     * @return
     */
    List<Object> getAllUser();
    /**
     * 保存用户
     * @param user
     * @return
     */
    boolean saveUser(Object user);
    /**
     * 根据用户uid删除该uid对应的用户信息
     * @param uid
     * @return
     */
    boolean deleteUser(int uid);
    /**
     * 更新指定用户信息
     * @param obj
     * @return
     */
    boolean updateUser(Object obj);
    void getUserByUid();
}

UserServiceImpl.java

@Component("us")
public class UserServiceImpl implements IUserService {
    @Override
    public List<Object> getAllUser() {
        System.out.println("--------getAllUser----------");
        return new ArrayList<>();
    }
    @Override
    public boolean saveUser(Object user) {
        System.out.println("--------saveUser----------");
        return true;
    }
    @Override
    public boolean deleteUser(int uid) {
        System.out.println("--------deleteUser----------");
        return false;
    }
    @Override
    public boolean updateUser(Object obj) {
        System.out.println("--------updateUser----------");
        return true;
    }
    @Override
    public void getUserByUid() {
        System.out.println("--------getUserByUid----------");
        String str = null;
        System.out.println(str.length());
    }
}

MyAspect.java

/**
 *  以注解的方式实现的切面类MyAspect
 *  当前类中的五种通知方式均以注解方式完成
 */
@Component//  标注当前类为一个组件
@Aspect//  标注当前类为一个切面类
public class MyAspect {
    /**
     * @Pointcut 注解为了避免相同的匹配规则被定义多处，专门定义该方法设置执行的匹配规则，各个自行调用即可
     *    write once， only once
     */
    @Pointcut(value = "execution(* com.aop6.*.*(..))")
    public void setAll(){}
    /**
     * @Before 表示该方法为一个前置通知
     * @param jp 连接点
     */
    @Before("setAll()")
    public void myBefore(JoinPoint jp){
        //System.out.println(jp.getArgs());
        System.out.println("this is before.");
    }
    /**
     * @After 表示该方法为一个后置通知
     * @param jp 连接点
     */
    @After("setAll()")
    public void myAfter(JoinPoint jp){
        //System.out.println(jp.getArgs());
        System.out.println("this is after.");
    }
    /**
     * @Around 表示该方法为一个环绕通知
     * @param pjp 处理连接点
     * @return 返回每个业务方法的返回值
     */
    @Around("setAll()")
    public Object myAround(ProceedingJoinPoint pjp){
        Object obj = null;
        try {
            System.out.println("this is around before");
            obj = pjp.proceed();
            System.out.println("this is around after");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        return obj;
    }
    /**
     * @AfterReturning 表示该方法为一个带有返回值的通知
     * @param jp 连接点
     * @param obj 业务方法的返回值
     */
    @AfterReturning(value = "setAll()", returning = "obj")
    public void myReturn(JoinPoint jp, Object obj){
        System.out.println("this is after returnning " + obj);
    }
    /**
     * @AfterThrowing 表示该方法为一个带有异常的通知
     * @param jp 连接点
     * @param e Throwable对象
     */
    @AfterThrowing(value = "setAll()", throwing = "e")
    public void myThrowing(JoinPoint jp, Throwable e){
        System.out.println("this is after throwing " + e.getMessage());
    }
}

TestAOP6.java

public class TestAOP6 {
    @Test
    public void testAOP6(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("com/aop6/beans.xml");
        IUserService us = ac.getBean("us", IUserService.class);
        us.getAllUser();
        us.deleteUser(1);
        us.saveUser("LKT");
        us.updateUser("GOD");
        us.getUserByUid();
    }
}

beans.xml

<?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"
       xmlns:context="http://www.springframework.org/schema/context"
       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
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="com.aop6" />
    <aop:aspectj-autoproxy />
</beans>

context:component-scan 组件扫描
base-package指定要扫描的包的路径
aop:aspectj-autoproxy标签实现自动代理

第七种方式

使用BeanPostProcessor方式实现Spring的AOP
IUserService.java

public interface IUserService {
    /**
     * 获取所有的用户对象列表
     * @return
     */
    List<Object> getAllUser();
    /**
     * 保存用户
     * @param user
     * @return
     */
    boolean saveUser(Object user);
    /**
     * 根据用户uid删除该uid对应的用户信息
     * @param uid
     * @return
     */
    boolean deleteUser(int uid);
    /**
     * 更新指定用户信息
     * @param obj
     * @return
     */
    boolean updateUser(Object obj);
    void getUserByUid();
}

UserServiceImpl.java

@Component("us")
public class UserServiceImpl implements IUserService {
    @Override
    public List<Object> getAllUser() {
        System.out.println("--------getAllUser----------");
        return new ArrayList<>();
    }
    @Override
    public boolean saveUser(Object user) {
        System.out.println("--------saveUser----------");
        return true;
    }
    @Override
    public boolean deleteUser(int uid) {
        System.out.println("--------deleteUser----------");
        return false;
    }
    @Override
    public boolean updateUser(Object obj) {
        System.out.println("--------updateUser----------");
        return true;
    }
    @Override
    public void getUserByUid() {
        System.out.println("--------getUserByUid----------");
        String str = null;
        System.out.println(str.length());
    }
}

UserServiceImpl2.java

//@Component("us2")
public class UserServiceImpl2 implements IUserService {
    @Override
    public List<Object> getAllUser() {
        System.out.println("--------getAllUser----------");
        return new ArrayList<>();
    }
    @Override
    public boolean saveUser(Object user) {
        System.out.println("--------saveUser----------");
        return true;
    }
    @Override
    public boolean deleteUser(int uid) {
        System.out.println("--------deleteUser----------");
        return false;
    }
    @Override
    public boolean updateUser(Object obj) {
        System.out.println("--------updateUser----------");
        return true;
    }
    @Override
    public void getUserByUid() {
        System.out.println("--------getUserByUid----------");
        System.out.println(1 / 0);
        String str = null;
        System.out.println(str.length());
    }
}

MyBeanPostProcessor.java

配置了包扫描之后，该类会初始化两个对象EventListenerMethodProcessor和DefaultEventListenerFactory，再外加组件对象，所以会发现有三个before打印

public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("this is before " + bean);
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("this is after");
        return Proxy.newProxyInstance(MyBeanPostProcessor.class.getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                MyAspect ma = new MyAspect();
                ma.before();
                Object obj = method.invoke(bean, args);
                ma.after();
                return obj;
            }
        });
    }
}

MyAspect.java - 自定义切面类

/**
 * 分别有前置方法和后置方法
 */
public class MyAspect {
    public void before(){
        System.out.println("this is my aspect before");
    }
    public void after(){
        System.out.println("this is my aspect after");
    }
}

beans.xml

<?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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <!--<bean id="us" class="com.aop7.UserServiceImpl" />-->
    <!--  base-package指定要扫描的包为com.aop7 -->
    <context:component-scan base-package="com.aop7" />
    <bean class="com.aop7.MyBeanPostProcessor" />
</beans>

context:component-scan上下文的组件扫描 base-package指定要扫描的包
指定BeanPostProcessor的Factory hook，让每个bean对象初始化是自动回调该对象中的回调方法

Spring AOP源码02 - 代理的创建
Spring AOP 的实现 Spring AOP 不同于 AspectJ 的 AOP 实现，是在 runtime...
spring-aop
aop概念aop概念aop术语AOP实现方式1、spring-aop(使用xml文件实现AOP)2、AspectJ...
Spring之AOP面向切面编程
十、AOP面向切面编程目录：什么是AOP、AOP在Spring中的作用、Spring实现AOP 1.什么是AOP...
Spring Aop、拦截器、过滤器的区别
Spring AOP Spring AOP，是AOP的一种实现，使用的是代理模式。 Filter Filter(过...
Spring
Spring的aop怎么实现，Spring的aop有哪些实现方式 AOP常用的实现方式有两种，一种是采用声明的方式...
[java][SpringAOP]
为什么会有AOP 实现AOP原理 AOP通知类型 AOP在Spring中配置
Spring AOP 实现原理
Spring AOP 实现原理静态代理众所周知 Spring 的 AOP 是基于动态代理实现的，谈到动态代理就...
Spring（3）——AOP
Spring学习总结——Spring实现AOP的多种方式
Spring一般切面
Spring一般切面 Spring 实现了AOP联盟Advice这个接口=>org.aopalliance.aop...
Spring 学习－－AOP
参考文献：深入浅析Spring 的aop实现原理Spring AOP 深入剖析AOP: 面向切面编程oop是从上往...

Spring AOP实现（3）

第六种方式

第七种方式

相关文章

Spring AOP源码02 - 代理的创建

spring-aop

Spring之AOP面向切面编程

Spring Aop、拦截器、过滤器的区别

Spring

[java][SpringAOP]

Spring AOP 实现原理

Spring（3）——AOP

Spring一般切面

Spring 学习－－AOP

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读