昆明java培训
达内昆明广州春城路

18487146383

热门课程

AOP面向切面编程的四种实现

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

昆明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培训教你实现JSP页面跳转简易方法,120天后月薪过万

昆明Java培训告诉你java和大数据和互联网发展中起什么作用

昆明java培训:初学者学Java Script 5个小技巧

昆明java培训多久可以学会?120天教你成为java开发大神!

选择城市和中心
贵州省

广西省

海南省

扫一扫

了解更多干货