Spring(六)AOP切入方式

一、接口切入方式

实现类

package com.pb.entity;

/**

 * 实体类

 */

public class Hello {

    private String name;

    private String password;

    public void show(){

        System.out.println("姓名 ："+this.getName()+"密码: "+this.getPassword());

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getPassword() {

        return password;

    }

    public void setPassword(String password) {

        this.password = password;

    }

}

1.1、前置增强

package com.pb.aop;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

/**

 * 前置增强的Bean

 * @author Administrator

 *实现MethodBeforeAdvice接口

 */

public class BeforeAdded implements MethodBeforeAdvice {

    @Override

    public void before(Method arg0, Object[] arg1, Object arg2)

            throws Throwable {

        System.out.println("====前置增强!=====");

    }

}

applicationContext.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:p="http://www.springframework.org/schema/p"

    xmlns:aop="http://www.springframework.org/schema/aop"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans-3.1.xsd

    http://www.springframework.org/schema/aop

    http://www.springframework.org/schema/aop/spring-aop-3.1.xsd">

<!--hello Bean  -->

<bean id="hello" class="com.pb.entity.Hello" p:name="张三" p:password="123qwe"/>

<!--切入的Bean  -->

<bean id="beforeAdd" class="com.pb.aop.BeforeAdded"/>

<!--前置增强切入的Bean  -->

<aop:config>

<!-- 切入点 -->

<aop:pointcut expression="execution(* com.pb.entity.Hello.*(..))" id="myPoint"/>

<!-- 关联切入类和切入点 -->

<aop:advisor advice-ref="beforeAdd" pointcut-ref="myPoint"/>

</aop:config>

</beans>

1.2、后置增强

package com.pb.aop;

import java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;

/**

 * 后置增强

 */

public class AfterAdded implements AfterReturningAdvice {

    @Override

    public void afterReturning(Object arg0, Method arg1, Object[] arg2,

            Object arg3) throws Throwable {

        System.out.println("====这里是后置增强!====");

    }

}

applicationContext.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:p="http://www.springframework.org/schema/p"

    xmlns:aop="http://www.springframework.org/schema/aop"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans-3.1.xsd

    http://www.springframework.org/schema/aop

    http://www.springframework.org/schema/aop/spring-aop-3.1.xsd">

<!--hello Bean  -->

<bean id="hello" class="com.pb.entity.Hello" p:name="张三" p:password="123qwe"/>

<!--切入的Bean  -->

<!--后置增强切入的Bean  -->

<bean id="afterAdd" class="com.pb.aop.AfterAdded"/>

<aop:config>

<!-- 切入点 -->

<aop:pointcut expression="execution(* com.pb.entity.Hello.*(..))" id="myPoint"/>

<!-- 关联后置增强切入类和切入点 -->

<aop:advisor advice-ref="afterAdd" pointcut-ref="myPoint"/>

</aop:config>

<!--后置增强切入的Bean  -->

</beans>

1.3、异常增强

实体类中增加异常

package com.pb.entity;

/**

 * 实体类

 */

public class Hello {

    private String name;

    private String password;

    public void show(){

        System.out.println("姓名 ："+this.getName()+"密码: "+this.getPassword());

        //加入异常

        System.out.println(1/0);

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getPassword() {

        return password;

    }

    public void setPassword(String password) {

        this.password = password;

    }

}

package com.pb.aop;

import java.lang.reflect.Method;

import org.springframework.aop.ThrowsAdvice;

/**

 * 异常增强类

 * @author Administrator

 *

 */

public class ThrowingAdded implements ThrowsAdvice {

    //第一种写法

    public void afterThrowing(Exception ex){

        System.out.println("我是异常增强!，，没处理异常，有问题就找我");

    }

    //第二种写法

    public void afterThrowing(Method arg0, Object[] arg1, Object arg2,Exception ex){

        System.out.println("我是异常增强!，，没处理异常，有问题就找我");

    }

}

applicationContext.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:p="http://www.springframework.org/schema/p"

    xmlns:aop="http://www.springframework.org/schema/aop"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans-3.1.xsd

    http://www.springframework.org/schema/aop

    http://www.springframework.org/schema/aop/spring-aop-3.1.xsd">

<!--hello Bean  -->

<bean id="hello" class="com.pb.entity.Hello" p:name="张三" p:password="123qwe"/>

<!--切入的Bean  -->

<!--异常增强切入的Bean  -->

<bean id="throwAdd" class="com.pb.aop.ThrowingAdded"/>

<aop:config>

<!-- 切入点 -->

<aop:pointcut expression="execution(* com.pb.entity.Hello.*(..))" id="myPoint"/>

<!-- 关联异常增强切入类和切入点 -->

<aop:advisor advice-ref="throwAdd" pointcut-ref="myPoint"/>

</aop:config>

</beans>

1.4、以上综合

<?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:p="http://www.springframework.org/schema/p"

    xmlns:aop="http://www.springframework.org/schema/aop"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans-3.1.xsd

    http://www.springframework.org/schema/aop

    http://www.springframework.org/schema/aop/spring-aop-3.1.xsd">

<!--hello Bean  -->

<bean id="hello" class="com.pb.entity.Hello" p:name="张三" p:password="123qwe"/>

<!--切入的Bean  -->

<!--前置增强切入的Bean  -->

<bean id="beforeAdd" class="com.pb.aop.BeforeAdded"/>

<!--后置增强切入的Bean  -->

<bean id="afterAdd" class="com.pb.aop.AfterAdded"/>

<!--异常增强切入的Bean  -->

<bean id="throwAdd" class="com.pb.aop.ThrowingAdded"/>

<aop:config>

<!-- 切入点 -->

<aop:pointcut expression="execution(* com.pb.entity.Hello.*(..))" id="myPoint"/>

<!-- 关联前置增强切入类和切入点 -->

<aop:advisor advice-ref="beforeAdd" pointcut-ref="myPoint"/>

<!-- 关联后置增强切入类和切入点 -->

<aop:advisor advice-ref="afterAdd" pointcut-ref="myPoint"/>

<!-- 关联异常增强切入类和切入点 -->

<aop:advisor advice-ref="throwAdd" pointcut-ref="myPoint"/>

</aop:config>

</beans>

1.5、环绕增强

package com.pb.entity;

/**

 * 实体类

 */

public class Hello {

    private String name;

    private String password;

    public void show(){

        System.out.println("姓名 ："+this.getName()+"密码: "+this.getPassword());

        //加入异常

        System.out.println(1/0);

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getPassword() {

        return password;

    }

    public void setPassword(String password) {

        this.password = password;

    }

}

环绕增加Bean

package com.pb.aop;

import org.aopalliance.intercept.MethodInterceptor;

import org.aopalliance.intercept.MethodInvocation;

/**

 * 环绕增强

 * @author Administrator

 *实现接口MethodIntercepor

 */

public class AroundAdded implements MethodInterceptor {

    @Override

    public Object invoke(MethodInvocation arg0) throws Throwable {

        Object result=null;

        try {

            System.out.println("环绕增强开始!");

             result=arg0.proceed();

            System.out.println("环绕增强结束!");

        } catch (Exception e) {

            System.out.println("环绕增强异常!");

        }finally{

            System.out.println("环绕增强最终增强!");

        }

        return result;

    }

}

applicationContext.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:p="http://www.springframework.org/schema/p"

    xmlns:aop="http://www.springframework.org/schema/aop"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans-3.1.xsd

    http://www.springframework.org/schema/aop

    http://www.springframework.org/schema/aop/spring-aop-3.1.xsd">

    <!-- 关联Bean Hello -->

<bean id="hello" class="com.pb.entity.Hello" p:name="张三" p:password="qewr"/>

<!--环绕增强的Bean  -->

<bean id="aroundAdded" class="com.pb.aop.AroundAdded"></bean>

<aop:config>

<!--  切入点-->

<aop:pointcut expression="execution(* com.pb.entity.*.*(..))" id="myPoint"/>

<!--关联切入点  -->

<aop:advisor advice-ref="aroundAdded" pointcut-ref="myPoint"/>

</aop:config>

</beans>

二、注解方式

package com.pb.entity;

/**

 * 实体类

 */

public class Hello {

    private String name;

    private String password;

    public void show(){

        System.out.println("姓名 ："+this.getName()+"密码: "+this.getPassword());

        //加入异常

        System.out.println(1/0);

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getPassword() {

        return password;

    }

    public void setPassword(String password) {

        this.password = password;

    }

}

aop的类

package com.pb.aop;

import org.aspectj.lang.JoinPoint;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.AfterReturning;

import org.aspectj.lang.annotation.AfterThrowing;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;

/**

 * 注解的方式现实AOP

 * @author Administrator

 *

 */

@Aspect

public class MyAnnotionAOP {

    /*

     * 前置

     */

    @Before(value="execution(* com.pb.entity.*.*(..))")

    public void before(JoinPoint point){

        System.out.println("前置增强");

        System.out.println(point.getClass());

    }

    /*

     * 后置

     */

    @AfterReturning(value="execution(* com.pb.entity.*.*(..))")

    public void after(JoinPoint point){

        System.out.println("后置增强");

        //参数个数

        System.out.println(point.getArgs().length);

    }

    /*

     *异常

     */

    @AfterThrowing(value="execution(* com.pb.entity.*.*(..))")

    public void afterThrowing(JoinPoint point){

        System.out.println("我是异常增强");

        System.out.println(point.getSignature().getName());

    }

    /**

     * 环绕

     */

    @Around(value="execution(* com.pb.entity.*.*(..))")

    public Object myAround(ProceedingJoinPoint point){

        Object result=null;

        try {

            System.out.println("环绕增强开始了");

            System.out.println(point.getKind()+point.getArgs());

            point.proceed();

            System.out.println("环绕增强后置增强了");

            System.out.println(point.getTarget()+""+point.getClass());

        } catch (Throwable e) {

            System.out.println("环绕增强,异常增强处理");

            e.printStackTrace();

        }finally{

            System.out.println("环绕增强最终增强");

        }

        return result;

    }

}

applicationContext.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:p="http://www.springframework.org/schema/p"

    xmlns:aop="http://www.springframework.org/schema/aop"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans-3.1.xsd

    http://www.springframework.org/schema/aop

    http://www.springframework.org/schema/aop/spring-aop-3.1.xsd">

<!-- 关联Bean Hello -->

<bean id="hello" class="com.pb.entity.Hello" p:name="张三" p:password="qewr"/>

<!-- 切入 类 -->

<bean id="myAnnAOP" class="com.pb.aop.MyAnnotionAOP" />

<!--开启自动代理  -->

<aop:aspectj-autoproxy/>

</beans>

三、Schema方式（推荐）

Hello类同上

package com.pb.entity;

/**

 * 实体类

 */

public class Hello {

    private String name;

    private String password;

    public void show(){

        System.out.println("姓名 ："+this.getName()+"密码: "+this.getPassword());

        //加入异常

        System.out.println(1/0);

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getPassword() {

        return password;

    }

    public void setPassword(String password) {

        this.password = password;

    }

}

aop类

package com.pb.aop;

import org.aspectj.lang.JoinPoint;

import org.aspectj.lang.ProceedingJoinPoint;

/**

 * SCHEMA方式切入类

 *

 * @author Administrator

 *

 */

public class MySchemaAOP {

    /**

     * 前置切入 可以有参数但是固定写法

     */

    public void before(JoinPoint point){

        System.out.println("这里是前置增强切入");

        System.out.println(point.getKind()+point.getArgs().toString());

    }

    /**

     * 后置切入

     */

    public void after(JoinPoint point){

        System.out.println("这里是后置增强切入");

        System.out.println(point.getTarget()+point.getSignature().getName());

    }

    /**

     * 异常切入

     */

    public void myException(JoinPoint point){

        System.out.println("这里是异常增强切入");

        System.out.println(point.getSourceLocation());

    }

    /**

     * 环绕增强切入

     */

    public Object myAround(ProceedingJoinPoint point){

        Object resut=null;

        try {

            System.out.println("环绕增强---前置增强");

            resut=point.proceed();

            System.out.println("环绕增强---后置增强");

        } catch (Throwable e) {

            System.out.println("环绕增强---异常增强");

            e.printStackTrace();

        }finally{

            System.out.println("环绕增强---最终增强");

        }

        return resut;

    }

}

applicationContext.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:p="http://www.springframework.org/schema/p"

    xmlns:aop="http://www.springframework.org/schema/aop"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans-3.1.xsd

    http://www.springframework.org/schema/aop

    http://www.springframework.org/schema/aop/spring-aop-3.1.xsd">

<!-- 关联Bean Hello -->

<bean id="hello" class="com.pb.entity.Hello" p:name="张三" p:password="qewr"/>

<!-- 切入 类 -->

<bean id="mySchemaAOP" class="com.pb.aop.MySchemaAOP"/>

<aop:config>

<!--  切入点-->

<aop:pointcut expression="execution(* com.pb.entity.*.*(..))" id="myPoint"/>

<!--关联切入类、方法和切入点  -->

<aop:aspect ref="mySchemaAOP">

<!-- 切入 前置方法和切入点-->

<aop:before method="before" pointcut-ref="myPoint"/>

<!-- 切入 后置方法和切入点-->

<aop:after method="after" pointcut-ref="myPoint"/>

<!-- 切入 异常方法和切入点-->

<aop:after method="myException" pointcut-ref="myPoint"/>

<!-- 切入 环绕增加方法和切入点-->

<aop:around method="myAround" pointcut-ref="myPoint"/>

</aop:aspect>

</aop:config>

</beans>

Spring(六)AOP切入方式的更多相关文章

【Spring】AOP注解方式实现机制
一.概述二.@EnableAspectJAutoProxy 注解分析三.分析AnnotationAwareAspectJAutoProxyCreator 四.执行流程 1. registerBea ...
【Spring】 AOP Base
1. AOP概述 2. AOP的术语: 3. AOP底层原理 4. Spring 中的AOP 4.1 概述 4.2 分类 4.3 Spring的传统AOP 针对所有方法的增强:(不带有切点的切面) 带 ...
Spring实现AOP的多种方式
转载自:https://www.cnblogs.com/best/p/5736422.html:加了一些自己的注释: AOP(Aspect Oriented Programming)面向切面编程,通过 ...
Spring之AOP原理、代码、使用详解(XML配置方式)
Spring 的两大核心,一是IOC,另一个是AOP,本博客从原理.AOP代码以及AOP使用三个方向来讲AOP.先给出一张AOP相关的结构图,可以放大查看. 一.Spring AOP 接口设计 1.P ...
【学习】Spring 的 AOP ：基于Annotation 的“零配置”方式
转自:http://www.cnblogs.com/jbelial/archive/2012/07/20/2539123.html AOP(Aspect Orient Programming ) , ...
spring(六)：spring中AOP的基本使用
AOP:面向切面编程[底层使用动态代理实现],就是在运行期间动态的将某段代码切入到方法的指定位置进行运行的编程方式基本使用使用AOP功能需要引入spring的aop以及aspects相关包 < ...
Spring系列之aAOP AOP是什么？+xml方式实现aop+注解方式实现aop
Spring系列之aop aop是什么?+xml方式实现aop+注解方式实现aop 什么是AOP? AOP为Aspect Oriented Programming 的缩写,意识为面向切面的编程,是通过 ...
Spring实现AOP的4种方式
了解AOP的相关术语:1.通知(Advice):通知定义了切面是什么以及何时使用.描述了切面要完成的工作和何时需要执行这个工作.2.连接点(Joinpoint):程序能够应用通知的一个“时机”,这些“ ...
（转）Spring AOP实现方式（转）
我们可以通过三种方式来使用Spring AOP,它们分别是:@Aspect-based(Annotation),Schema-based(XML),以及底层的Spring AOP API 底层的Spr ...

随机推荐

快速开发~Rafy框架的初步认识
当我们开始使用EF的同时,是不是就会更好的认识了其他的ORM框架,最近接触了Rafy的使用,感觉还是蛮有兴趣去学习的,虽然最初的我到现在看的并不深入,但是我个人感觉还是可以简单地做一些总结的啦,或许语 ...
程序设置横屏后，锁屏时会被销毁一遍，解锁时又重新加载onCreat的问题解决
今天在写一个应用的时候,因为需要设置成横屏模式,所以在Manifest里面的Activity里面加了两个参数设置: android:screenOrientation="landscape& ...
[IR] Ranking - top k
PageRanking 通过: Input degree of link "Flow" model - 流量判断喜好度传统的方式又是什么呢? Every term在某个doc中的 ...
node.js JS对象和JSON字符串之间的转换
JSON.stringify(obj)将JS对象转为字符串. var json = { aa: ['sdddssd'], bb: [ '892394829342394792399', '23894 ...
Clipping Magic – 帮助你轻松删除图片背景
Clipping Magic 让您轻松去除图片的背景,可以根据路径进行裁剪.操作很简单,只需拖动图像到放置区,或使用按钮选择文件.标记前景为绿,背景为红色,然后标记算法会帮助你处理好细节.处理后的图片 ...
[linux]执行pip安装的程序：command not found
执行pip安装的程序:command not found 问题描述: 我有一台阿里云服务器,上面装的是centos系统,我用pip安装好vituralenv,都没办法直接启动.同样我今天在部署我的t ...
springMVC基础
controllers包写控制器: @Controller @RequestMapping(value="/utils") public class UploadControlle ...
Sql Server来龙去脉系列必须知道的权限控制基础篇
题外话:最近看到各种吐槽.NET怎么落寞..NET怎么不行了..NET工资低的帖子.我也吐槽一句:一个程序猿的自身价值不是由他选择了哪一门技术来决定,而是由他自身能创造出什么价值来决定. 在进入本篇内 ...
关于window.onload，window.onbeforeload与window.onunload
★ window.onload 当页面加载完毕的时候执行,即在当前页面进行其他操作之前执行.如,刚进入某个网页的弹窗提示. ( 与window.onload相近的可以参考我写的另外一篇记录&qu ...
Python基础：函数
一.概述二.声明.定义和调用三.参数 1.参数传递 2.实参类型 3.形参绑定四.返回值五.名字空间与作用域 1.基本概念 2.名字空间 3.作用域 4.总原则六.高级 1.装饰器 2.生成 ...

Spring(六)AOP切入方式

一、接口切入方式

1.1、前置增强

1.2、后置增强

1.3、异常增强

1.4、以上综合

1.5、环绕增强

二、注解方式

三、Schema方式（推荐）

Spring(六)AOP切入方式的更多相关文章

随机推荐

热门专题