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

随机推荐

Linux curl使用简单介绍
在两台新搬迁的微信服务器上执行命令: curl -H "Content-Type: application/json" -d '{"partner_no":&q ...
springboot themleaf 开发笔记
<form id="form-query" th:action="@{/member-score/rule-save}" th:object=" ...
[OpenCV] IplImage and Functions
In this chapter, APIs will make U crazy. Good luck! Next, Review Linear Algebra. Ref: http://blog.c ...
Android 学习笔记之ContentProvider实现数据共享....
PS:最近听老师说打算让我参与企业的app制作,让我加快学习的进度...好吧,貌似下周还有考试...貌似实验室这个app也要做...暂时不管了...那就只能加快进度了,感觉略微的有点激动和紧张,总算是 ...
基于Lumisoft.NET组件的SMTP账号登陆检测
在邮件处理的方面,Lumisoft.NET可以说是非常不错的一个选择,我在前面几篇文章中都介绍过这个组件. 基于Lumisoft.NET组件开发碰到乱码等一些问题的解决基于Lumisoft.NET组 ...
Python基础：映射（字典）
一.概述映射类型(Mapping Types)是一种关联式的容器类型,它存储了对象与对象之间的映射关系. 字典(dict)是Python中唯一的映射类型,它是存储了一个个键值对(由键映射到值 ...
ASP.Net中Session失效的一种编程思路
在写一个客户的B/S结构应用程序时,突然发现一个技巧,不知道是否是MS的一个BUG,给相关的有研究的朋友原先考虑写一个检查Session的类,Session失效后,必须转向登陆页面,可每一个调用该类的 ...
sql 去重
;WITH CETAS (SELECT *, ROW_NUMBER() OVER (PARTITION BY SearchTask_PKID ORDER BY SearchTask_PKID) Row ...
AppCan可以视为Rexsee的存活版
今天看到地宝的几个APP用appcan做的,我顿时惊呆了. 1. 走的同样是中间件的模式,支持原生UI界面的访问: 2. 在线打包的方式,进行资源的限制,以便商业化支持:
使用layout_weight设置控件占屏幕百分比
水平LinearLayout中如果A,B两个控件都是layout_weight="1",那么控件在水平方向占比为A的layout_width+1/2空闲空间,B的layout_wi ...

Spring(六)AOP切入方式

一、接口切入方式

1.1、前置增强

1.2、后置增强

1.3、异常增强

1.4、以上综合

1.5、环绕增强

二、注解方式

三、Schema方式（推荐）

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

随机推荐

热门专题