Spring的AOP简介和Spring中的通知使用方法以及异常

红太狼 2022-04-11 09:43 279阅读 0赞

**AOP中关键性概念**

**连接点(Joinpoint)：程序执行过程中明确的点，如方法的调用，或者异常的抛出.**

**目标(Target)：被通知(被代理)的对象**

**注1：完成具体的业务逻辑**

**通知(Advice)：在某个特定的连接点上执行的动作，同时Advice也是程序代码的具体实现，例如一个实现日志记录的代码(通知有些书上也称为处理)**

**注2：完成切面编程**

**代理(Proxy)：将通知应用到目标对象后创建的对象(代理=目标+通知),**

**             例子：外科医生+护士**

**注3：只有代理对象才有AOP功能，而AOP的代码是写在通知的方法里面的**

**切入点(Pointcut)：多个连接点的集合，定义了通知应该应用到那些连接点。**

**      (也将Pointcut理解成一个条件 ，此条件决定了容器在什么情况下将通知和目标组合成代理返回给外部程序)**

**适配器(Advisor)：适配器=通知(Advice)+切入点(Pointcut)**

**如何实现AOP**

**目标对象只负责业务逻辑代码**

**通知对象负责AOP代码，这二个对象都没有AOP的功能，只有代理对象才有**

# 接下来贴上案例代码来实现通知: #

### biz ###

public interface IBookBiz {
    	// 购书
    	public boolean buy(String userName, String bookName, Double price);
    
    	// 发表书评
    	public String comment(String userName, String comments);
    }

### biz实现 ###

public class BookBizImpl implements IBookBiz {
    
        public BookBizImpl() {
            super();
        }
    
        public boolean buy(String userName, String bookName, Double price) {
            // 通过控制台的输出方式模拟购书   如果价格不对将会触发异常,导致程序停止,但是触发前的事件依然会执行
            if (null == price || price <= 0) {
                throw new PriceException("book price exception");
            }
            System.out.println(userName + " buy " + bookName + ", spend ASD " + price);
            return true;
        }
    
        public String comment(String userName, String comments) {
            // 通过控制台的输出方式模拟发表书评
            System.out.println(userName + " say:" + comments);
            return "123";
        }
    
    }

# 然后我们写一个前后置通知的类 #

/**
     * @program: Maven
     * @description: 前置后置通知
     * @author: hw
     * MethodBeforeAdvice   为前置通知的接口    AfterReturningAdvice为后置通知接口
     **/
    public class MyMethodBeforeAdvice implements MethodBeforeAdvice, AfterReturningAdvice {
        /**
         * @Description: 前置通知方法
         * @Param: [method, objects, o]
         * @return: void
         * @Author: hw
         */
        @Override
        public void before(Method method, Object[] objects, Object o) throws Throwable {
            //类名
            String name = o.getClass().getName();
            //方法名
            String name1 = method.getName();
            //参数
            String s = Arrays.toString(objects);
            System.out.println("前置类名" + name + "方法名" + name1 + "参数" + s);
        }
    
        /**
         * @Description: 后置通知方法
         * @Param: [o, method, objects, o1]
         * @return: void
         * @Author: hw
         */
        @Override
        public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
            //类名
            String name = o1.getClass().getName();
            //方法名
            String name1 = method.getName();
            //参数
            String s = Arrays.toString(objects);
            System.out.println("后置类名" + name + "方法名" + name1 + "参数" + s+"返回值"+o);
        }
    
    }

# 这是环绕通知的类,也就是即会在方法执行前执行也会在方法执行后执行,概念像struts的拦截器 #

/**
     * @program: Maven
     * @description: 环绕通知
     * @author: hw
     **/
    public class MyMethodInterceptor implements MethodInterceptor {
        /**
         * @Description: 环绕通知, 前后都执行
         * @Param: [methodInvocation]
         * @return: java.lang.Object
         * @Author: hw
         * @Date: 2018/12/5
         */
        @Override
        public Object invoke(MethodInvocation methodInvocation) throws Throwable {
            //执行前
            //类名
            String name = methodInvocation.getThis().getClass().getName();
            //方法名
            String name1 = methodInvocation.getMethod().getName();
            //参数
            String s = Arrays.toString(methodInvocation.getArguments());
            System.out.println("环绕前"+ name + "方法名" + name1 + "参数" + s);
            //执行后通知以下面这行代码分割
            Object proceed = methodInvocation.proceed();//返回值
            //后置通知
            System.out.println("环绕后" + name + "方法名" + name1 + "参数" + s+"返回值"+proceed);
            return proceed;
        }
    }

# 异常类 #

/**
     * @program: Maven
     * @description: 异常
     * @author: hw
     **/
    public class MyThrowsAdvice implements ThrowsAdvice {
    /** @Description: 这个方法需要手写出来,并且方法名必须是这个,但是可以通过方法重构使用多个方法
        * @Param: [ex]
        * @return: void
        * @Author: hw
        */ 
        public void afterThrowing(PriceException ex) {
            System.out.println("价格异常");
        }
    }

/**
     * @Description: 异常类
     * @Param:
     * @return:
     * @Author: hw
     */
    public class PriceException extends RuntimeException {
    
        public PriceException() {
            super();
        }
    
        public PriceException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
            super(message, cause, enableSuppression, writableStackTrace);
        }
    
        public PriceException(String message, Throwable cause) {
            super(message, cause);
        }
    
        public PriceException(String message) {
            super(message);
        }
    
        public PriceException(Throwable cause) {
            super(cause);
        }
    
    }

# 接下来是我们最后的配置文件 #

<bean class="com.hw.two.biz.impl.BookBizImpl" name="bookBiz"></bean>
        
        <bean class="com.hw.two.advice.MyMethodBeforeAdvice" name="MymethodBeforeAdvice"></bean>
        
        <bean class="com.hw.two.advice.MyMethodInterceptor" name="myinterceptor"></bean>
        
        <bean class="com.hw.two.advice.MyThrowsAdvice" name="throwsAdvice"></bean>
        
        <bean class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"
            name="pointcutAdvisor">
            
            <property name="advice" ref="MymethodBeforeAdvice"></property>
            
            <property name="pattern" value=".*buy"></property>
        </bean>
        
        <bean class="org.springframework.aop.framework.ProxyFactoryBean" name="bookProxy">
            
            <property name="target" ref="bookBiz"></property>
            
            <property name="proxyInterfaces">
                <list>
                    <value>com.hw.two.biz.IBookBiz</value>
                </list>
            </property>
            
            <property name="interceptorNames">
                <list>
                    
                    
                    
                    <value>pointcutAdvisor</value>
                    
                    <value>myinterceptor</value>
                    
                    <value>throwsAdvice</value>
                </list>
            </property>
        </bean>

# 测试类 #

/**
     * @program: Maven
     * @description: 通知测试
     * @author: hw
     **/
    public class AdviceTest {
        public static void main(String[] args) {
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-context.xml");
            Object bookProxy = applicationContext.getBean("bookProxy");
            IBookBiz biz= (IBookBiz) bookProxy;
            biz.buy("猴子","升序",12.5);
            System.out.println();
            biz.comment("猴子","sss");
        }
    }

# 结果 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTk0MTQ2_size_16_color_FFFFFF_t_70][]

# 大多注释都写在代码中,如有什么问题,欢迎下方留言讨论 #

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTk0MTQ2_size_16_color_FFFFFF_t_70]: /images/20220411/1edd7c67c6bd49169ec05cfda292203a.png