课程咨询 :186 8716 1620      qq:2066486918

昆明Java培训 > 达内新闻 > AOP面向切面编程的四种实现
  • AOP面向切面编程的四种实现

    发布:昆明Java培训      来源:达内新闻      时间:2016-10-21

  • 昆明Java培训的老师知道,AOP(面向切面编程)的四种实现分别为最原始的经典AOP、代理工厂bean(ProxyFacteryBean)和默认自动代理DefaultAdvisorAutoProxyCreator以及BeanNameAutoProxyCreator代理、Aspectj的注解和xml配置文件。

    1.代理工厂bean(ProxyFacteryBean)的方式

    1.1接口(Interface)

    1 package cn.happy.interfaces;

    2

    3 public interface Advice {

    4

    5    public void fristMethod();

    6    

    7    public String secondMethod();

    8 }

    1.2 接口的实现类

    1 package cn.happy.impl;

    2

    3 import cn.happy.interfaces.Advice;

    4

    5 public class AdviceImpl implements Advice {

    6

    7    public void fristMethod() {

    8         System.out.println("==fristMethod==");

    9    }

    10

    11    public String secondMethod() {

    12        System.out.println("==secondMethod==");

    13        return "abc";

    14    }

    15

    16 }

    1.3各种通知增强

    1.3.1前置增强

    1 package cn.happy.advice;

    2

    3 import java.lang.reflect.Method;

    4

    5 public class MethodBeforeAdvice implements

    6        org.springframework.aop.MethodBeforeAdvice {

    7

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

    9            throws Throwable {

    10        System.out.println("==Before==");

    11         

    12    }

    13

    14 }

    1.3.2 后置增强

    1 package cn.happy.advice;

    2

    3 import java.lang.reflect.Method;

    4

    5 import org.springframework.aop.AfterReturningAdvice;

    6

    7 public class AfterReturningAdvie implements AfterReturningAdvice {

    8

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

    10            Object arg3) throws Throwable {

    11        System.out.println("==After==");

    12

    13    }

    14

    15 }

    1.3.3 环绕增强

    package cn.happy.aroundadvice;

    import org.aopalliance.intercept.MethodInterceptor;

    import org.aopalliance.intercept.MethodInvocation;

    public class MyInterceptor implements MethodInterceptor{

    public Object invoke(MethodInvocation invocation) throws Throwable {

    System.out.println("==before==");

    String result= (String)invocation.proceed();

    System.out.println("==after==");

    return result;

    }

    }

    1.3.4异常增强

    package cn.happy.exception;

    import org.springframework.aop.ThrowsAdvice;

    public class MyException implements ThrowsAdvice {

    public void afterThrowing(Exception ex){

    System.out.println("异常通知");

    }

    }

    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: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="adviceimpl" class="cn.happy.impl.AdviceImpl"></bean>

    <!--前置增强 通知-->

    <bean id="advicebefore" class="cn.happy.advice.MethodBeforeAdvice"></bean>

    <!--后置增强 通知-->

    <bean id="adviceafter" class="cn.happy.advice.AfterReturningAdvie"></bean>

    <!--环绕增强-->

    <bean id="around" class="cn.happy.aroundadvice.MyInterceptor"></bean>

    <!--关联 代理工厂bean ProxyFacteryBean通知-->

    <!--<bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">

    <property ame="targetName" value="adviceimpl"></property>

    <property ame="interceptorNames" value="advicebefore,adviceafter"></property>

    </bean>-->

    <!--环绕增强代理工厂顾问包装通知-->

    <bean id="aroundserviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">

    <property name="target" ref="adviceimpl"></property>

    <property ame="interceptorNames" value="beforeadvisor"></property>

    </bean>

    <!--切面 通知 -->

    <bean id="beforeadvice" class="cn.happy.mymethodbefore.MyMethodBeforeAdvice"></bean>

    <!--顾问 包装advice -->

    <bean id="beforeadvisor" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">

    <property name="advice" ref="beforeadvice"></property>

    <property ame="mappedNames" value="fristMethod,secondMethod"></property>

    </bean>

    <!--顾问 包装advice正则表达式-->

    <!--<bean id="beforeadvisor1" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">

    <property name="advice" ref="beforeadvice"></property>

    <property name="pattern" value=".*Method.*"></property>

    </bean>-->

    <!--默认自动代理 默认只找通知-->

    <!--<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"></bean>-->

    <!-- beanname自动代理可以选择顾问或者通知-->

    <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">

    <property ame="beanNames" value="adviceimpl"></property>

    <property ame="interceptorNames" value="beforeadvisor"></property>

    </bean>

    </beans>

    1.5测试类

    package cn.happy.test;

    import org.springframework.context.ApplicationContext;

    import org.springframework.context.support.ClassPathXmlApplicationContext;

    import cn.happy.interfaces.Advice;

    public class Test {

    /**

    *通知的前置和后置测试

    */

    public static void main(String[] args) {

    //解析配置文件

    ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");

    Advice advice= (Advice)ctx.getBean("adviceimpl"); //自动代理beanname的方式

    advice.fristMethod();

    advice.secondMethod();

    }

    }

    2.最原始的经典AOP

    2.1最基本分层模式dao、biz、service以及最后测试Test

    2.1.1DAO层

    package cn.happy.dao;

    import cn.happy.entity.User;

    //接口

    public interface UDao {

    //保存方法

    public void save(User user);

    }

    //实现类

    package cn.happy.dao;

    import cn.happy.entity.User;

    public class UserDaoImpl implements UDao{

    public void save(User user) {

    System.out.println("保存成功");

    }

    }

    2.1.2 BIZ层

    package cn.happy.biz;

    import cn.happy.entity.User;

    //业务接口

    public interface UBiz {

    //保存方法

    public void save2(User user);

    }

    //业务实现类

    package cn.happy.biz;

    import cn.happy.dao.UDao;

    import cn.happy.entity.User;

    public class UserBiz implements UBiz{

    //dao的对象

    private UDao udao;

    public void save2(User user) {

    udao.save(user);

    }

    public UDao getUdao() {

    return udao;

    }

    public void setUdao(UDao udao) {

    this.udao = udao;

    }

    }

    2.1.3 AOP模块即service层

    package cn.happy.logger;

    import java.lang.reflect.Method;

    import org.springframework.aop.MethodBeforeAdvice;

    //前置内容

    public class LoggerBefore implements MethodBeforeAdvice {

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

    throws Throwable {

    System.out.println("save前置内容");  

    }

    }

    //后置内容

    package cn.happy.logger;

    import java.lang.reflect.Method;

    import org.springframework.aop.AfterReturningAdvice;

    public class LoggerAfter implements AfterReturningAdvice{

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

    Object arg3) throws Throwable {

    System.out.println("save后置内容");  

    }

    }

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

    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-4.1.xsd">

    <!--业务biz与dao接口对象的实现-->

    <bean id="dao" class="cn.happy.dao.UserDaoImpl"></bean>

    <bean id="biz" class="cn.happy.biz.UserBiz">

    <property name="udao" ref="dao"></property>

    </bean>

    <!--前置与后置内容的配置-->

    <bean id="before" class="cn.happy.logger.LoggerBefore"></bean>

    <bean id="after" class="cn.happy.logger.LoggerAfter"></bean>

    <!-- aop的配置-->

    <aop:config>

    <aop:pointcut expression="execution(public void save2(cn.happy.entity.User))" id="pointcut"/>

    <!--在切入点处插入增强处理、完成"织入" -->

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

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

    </aop:config>

    </beans>      

    2.1.5 测试类

    package cn.happy.test;

    import org.springframework.context.ApplicationContext;

    import org.springframework.context.support.ClassPathXmlApplicationContext;

    import cn.happy.biz.UBiz;

    import cn.happy.entity.User;

    public class AOPTest {

    public static void main(String[] args) {

    ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");

    UBiz ubiz=(UBiz)context.getBean("biz");

    User user=new User();

    ubiz.save2(user);

    System.out.println("save~ok");

    }

    }

    3.然后就是Aspectj的注解以及xml配置文件的两种方式了。

    3.1 Aspectj注解

    3.1.1接口和实现类

    package cn.happy.impl;

    //接口

    public interface AspectDao {

    public void add();

    public void delete();

    }

    //实现类

    package cn.happy.impl;

    public class AspectjIpml implements AspectDao{

    //添加

    public void add() {

    System.out.println("==ADD==");

    }

    //删除

    public void delete() {

    System.out.println("==DELETE==");  

    }

    }

    3.1.2注解类Aspect

    package cn.happy.aspectj;

    import org.aspectj.lang.ProceedingJoinPoint;

    import org.aspectj.lang.annotation.After;

    import org.aspectj.lang.annotation.AfterReturning;

    import org.aspectj.lang.annotation.AfterThrowing;

    import org.aspectj.lang.annotation.Around;

    import org.aspectj.lang.annotation.Before;

    @org.aspectj.lang.annotation.Aspect

    public class Aspect {

    //前置增强

    @Before(value="execution(public * *(..))")

    public void asBefore(){

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

    }

    //后置增强

    @AfterReturning(value="execution(public * *(..))")

    public void asAfterReturning(){

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

    }

    //环绕增强

    @Around(value="execution(public * *(..))")

    public void asAround(ProceedingJoinPoint pj){

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

    try {

    pj.proceed();

    } catch (Throwable e) {

    //抓捕异常

    e.printStackTrace();

    }

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

    }

    //异常增强

    @AfterThrowing(value="execution(public * *(..))")

    public void asThorws(){

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

    }

    //最终增强

    @After(value="execution(public * *(..))")

    public void asAfter(){

    System.out.println("这是最终增强");

    }

    }

    3.1.3 注解的配置文件

    <?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"

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

    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

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

    <!--目标对象-->

    <bean id="aspectimpl" class="cn.happy.impl.AspectjIpml"></bean>

    <!--增强类-->

    <bean id="aspectj" class="cn.happy.aspectj.Aspect"></bean>

    <!--扫描整个项目关联注解类和实现类-->

    <aop:aspectj-autoproxy />

    </beans>

    3.1.4  测试类

    package cn.happy.test;

    import org.springframework.context.ApplicationContext;

    import org.springframework.context.support.ClassPathXmlApplicationContext;

    import cn.happy.impl.AspectDao;

    public class AspectjTest {

    /**

    *注解测试*/

    public static void main(String[] args) {

    //解析配置文件

    ApplicationContext ctx = new ClassPathXmlApplicationContext(

    "applicationContext.xml");

    AspectDao aspect = (AspectDao) ctx.getBean("aspectimpl");

    aspect.add();

    aspect.delete();

    }

    }

    4. Aspectj的XML配置法,其他的基本都一样只要修改Aspectj增强类和配置文件就行了

    4.1 Aspect增强类只需将那些注解消去即可

    package cn.happy.aspectj;

    import org.aspectj.lang.ProceedingJoinPoint;

    public class Aspect {

    //前置增强

    public void asBefore(){

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

    }

    //后置增强

    public void asAfterReturning(){

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

    }

    //环绕增强

    public void asAround(ProceedingJoinPoint pj){

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

    try {

    pj.proceed();

    } catch (Throwable e) {

    //抓捕异常

    e.printStackTrace();

    }

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

    }

    //异常增强

    public void asThorws(){

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

    }

    //最终增强

    public void asAfter(){

    System.out.println("这是最终增强");

    }

    }

    4.2 XML的配置文件会稍微会复杂一点,但大致的还是跟对原始的经典aop实现方式相同

    <?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"

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

    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

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

    <!--目标对象-->

    <bean id="aspectimpl" class="cn.happy.impl.AspectjIpml"></bean>

    <!--增强类-->

    <bean id="aspectj" class="cn.happy.aspectj.Aspect"></bean>

    <!-- Aspectj的XML配置文件-->

    <aop:config>

    <aop:pointcut expression="execution(public * *(..))" id="pointcut"/>

    <aop:aspect ref="aspectj">

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

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

    <aop:after-returning method="asAround(org.aspectj.lang.ProceedingJoinPoint)" pointcut-ref="pointcut"/>

    </aop:aspect>

    </aop:config>

    </beans>

    好了,这就是昆明Java培训的老师讲的AOP(面向切面编程)的四种实现方式了。希望同学们看了之后能让你们对AOP面向切面编程思想有更深的了解。

    推荐文章

上一篇:【昆明Java培训】finally在return之后执行还是之前?

下一篇:Java的系统漏洞:关于用户登录后操作的注意事项

最新开班日期  |  更多

Java--零基础全日制班

Java--零基础全日制班

开班日期:11/30

Java--零基础业余班

Java--零基础业余班

开班日期:11/30

Java--周末提升班

Java--周末提升班

开班日期:11/30

Java--零基础周末班

Java--零基础周末班

开班日期:11/30

  • 网址:http://km .java.tedu.cn      地址:昆明市官渡区春城路62号证券大厦附楼6楼
  • 课程培训电话:186 8716 1620      qq:2066486918    全国服务监督电话:400-827-0010
  • 服务邮箱 ts@tedu.cn
  • 2001-2016 达内国际公司(TARENA INTERNATIONAL,INC.) 版权所有 京ICP证08000853号-56