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 ...

随机推荐

swift也开源了.
swift也开源了微软好多也开源. 这世界都开源了你还等啥. 是因为 B2D 模式吗. 开发者人数众多, 足可以养活一个公司了. 有的叫生态圈.
call方法和new对象的关系
call只能改变this的指向,而使用new对象不仅会自动调用call方法改变这个对象的this指向,而且还会继承构造函数的原型. var fn = function(a){ this.a = a; ...
Oracle实例和服务知识点
shutdown是对实例而言 service是启动的,根本不代表instance就是启动的. 启动数据库基本可分为三个过程: 1,nomount(即只启动instance,而不加载数据库) 2,mo ...
Android 布局之LinearLayout
Android 布局之LinearLayout 1 LinearLayout简介 LinearLayout是线程布局.它包括2个方向(android:orientation):“水平”(horizon ...
[OpenCV] IplImage and Functions
In this chapter, APIs will make U crazy. Good luck! Next, Review Linear Algebra. Ref: http://blog.c ...
git回滚到上一版本
git reset --hard HEAD~1
[C] static和extern的作用
static: 当用于函数定义或者代码块之外的变量声明时,static关键字用于修改标识符的链接属性,从external改为internal. 当用于代码块内部的变量声明时,static关键字用于修改 ...
Android 学习笔记 Service服务与远程通信...（AIDL）
PS:这一章节看的我有几分迷茫,不是很容易理解...不过还好总算是明白了一大半了...基本的迷惑是解决了... 学习内容: 1.跨应用启动服务... 2.跨应用绑定服务... 3.跨应用实现通信... ...
linux 系统管理使用技巧
一.这篇文章讲了什么? 这篇文章很有参考性哈.本来是想等一段时间有更多条技巧后在发布的,不过,突然发现,我是去年的今天在博客园落户了,祝我的博客一周岁快乐,希望以后多分享一些文章啦.所以就把草稿箱的其 ...
更加优雅地搭建SSH框架（使用java配置）
时代在不断进步,大量基于xml的配置所带来的弊端也显而易见,在XML配置和直接注解式配置之外还有一种有趣的选择方式-JavaConfig,它是在Spring 3.0开始从一个独立的项目并入到Sprin ...

Spring(六)AOP切入方式

一、接口切入方式

1.1、前置增强

1.2、后置增强

1.3、异常增强

1.4、以上综合

1.5、环绕增强

二、注解方式

三、Schema方式（推荐）

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

随机推荐

热门专题