一、AOP 的概念
AOP(Aspect Oriented Programming)的缩写,面向切面编程,主要作用就是对代码进行增强处理。
理解面向切面编程的含义:就是在不改变原有程序的基础上为代码增加新的功能。
实现面向切面编程需要了解两个概念:
>切入点:可以插入增强处理的方法,比如原对象的fun()方法。
>增强处理类型:在原对象fun()方法之前还是之后插入新功能。
1.新建一个java项目
2.到官网下载Spring AOP和AspectJ框架所需要的jar包,并将下载所需的jar文件添加到项目中。
3.在项目中添加User实体类
package com.jbit.fsd.entity;public class User { private int id; private String username; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } }
4.添加数据访问层接口和实现类,并添加相应的方法
package com.jbit.fsd.dao;import java.util.List;import com.jbit.fsd.entity.User;// 数据访问层接口public interface UserDao { public List<User> getAll(); public void addUser(User user);}
实现类:
package com.jbit.fsd.dao.impl;import java.util.ArrayList;import java.util.List;import com.jbit.fsd.dao.UserDao;import com.jbit.fsd.entity.User;public class UserDaoImpl implements UserDao { @Override public List<User> getAll() { //操作数据库读到所有数据 List<User> list=new ArrayList<User>(); list.add(new User()); list.add(new User()); list.add(new User()); return list; } @Override public void addUser(User user) { System.out.println("添加成功"); }}
5.添加业务处理层接口和实现类
package com.jbit.fsd.service;import java.util.List;import com.jbit.fsd.dao.UserDao;import com.jbit.fsd.entity.User;public interface UserService { public List<User> getAll(); public void addUser(User user); }
实现类:
package com.jbit.fsd.service.impl;import java.util.List;import com.jbit.fsd.dao.UserDao;import com.jbit.fsd.entity.User;import com.jbit.fsd.service.UserService;public class UserServiceImpl implements UserService{ private UserDao dao; //通过spring注入进来 public void setDao(UserDao dao) { this.dao = dao; } @Override public List<User> getAll() { System.out.println("正在执行添加用户的业务!"); return dao.getAll(); } @Override public void addUser(User user) {
System.out.println("正在执行添加用户的业务!"); dao.addUser(user); }}
6.添加AOP增强处理类
package com.jbit.fsd.aop;import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;public class ServiceLoging { private Log log = LogFactory.getLog(this.getClass()); public void beforeService(){ log.info("aop方法被调用!"); }}
7.在src目录下新建applicationContext.
<? http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"> <!-- 以面向接口思想编程实现解耦和 --> <bean id="userDao" > </bean> <bean id="userServiceImpl" > <property name="dao" ref="userDao"></property> <!-- 属性注入 --> </bean> <!-- 配置切面 --> <bean id="serviceLogging" ></bean> <aop:config> <!-- 配置切入点 --> <aop:pointcut expression="execution(public void addUser(com.jbit.fsd.entity.User))" id="servicePointcut"/> <!-- 将切面和切入点编制在一起--> <aop:aspect ref="serviceLogging"> <aop:before method="beforeService" pointcut-ref="servicePointcut"/> </aop:aspect> </aop:config></beans>
8.main方法测试:
package com.jbit.fsd.test;import java.util.List;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPath
说明:
1.在.
2.AOP相关的配置在<aop:config>标签中,切入点的配置在<aop:pointcut>标签中。
3.execution是切入点的标识符,括号是切入点的表达式,配置需要增强的方法。
4.切入点表达式常用几种模糊匹配方式:
>public * addUser(com.able.entity.User),“*”表示配置所有类型的返回值。
>public void * (com.able.entity.User), "*"代表匹配所有的方法名。
>public void addUser(..), " .. "表示匹配所有参数个数和类型。
> * com.able.service.*.*( . . ), 表示匹配com.able.service包下面所有类的所有方法。
> * com.able.service . . *(), 表示匹配com.able.service包以及子包下所有类的所有方法。
三、增强处理类型简介
1.前置增强处理
特点:在目标方法前织入增强处理。
<aop:before method="beforeService" poontcut-ref="servicePointcut"/>
如果想在这个方法中获得切入点的信息,使用如下方法:
package com.jbit.fsd.aop;import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;import org.aspectj.lang.JoinPoint;public class ServiceLoging { private Log log = LogFactory.getLog(this.getClass()); public void beforeService(JoinPoint joinPoint){ System.out.println("aop方法被调用"); System.out.println("连接点对象:"+joinPoint.getTarget().getClass().getSimpleName()); System.out.println("连接点方法:"+joinPoint.getSignature()); System.out.println("连接点方法参数:"+joinPoint.getArgs()[0]); }}
2.后置增强处理
特点:在目标方法正常执行(不出现异常)后织入增强处理。
<aop:after-returning method="afterReturning" pointcut-ref="servicePointcut"/>
如果需要获取返回值,添加returning="returnVal"
<aop:after-returning method="aft" pointcut-ref="ser" returning="returnVal"/>
public void afterService(Object returnVal){ System.out.println(returnVal); }
3.异常增强处理
特点:在目标方法出现异常后织入增强处理。
<aop:after-throwing mehod=" " pointcut-ref=" " throwing ="ex"/>
如果需要获取异常对象才添加throwing="ex"
public void afterThrowing(Exception ex){ System.out.println(ex.getMessage()); }
4.最终增强处理
特点:不论方法是否抛异常,都会在目标方法最后织如增强处理,类似与finally。
<aop:after method="after" pointcut-ref="servicePointcut"/>
5.环绕增强处理
特点:在目标方法的前后都可以织入增强处理。
<aop:around method="" pointcut-ref="" />
public Boolean around(ProceedingJoinPoint pjp) throws Throwable{ System.out.println("目标方法的参数:"+pjp.getArgs()[0]); Boolean b = null; if (true) { b = (Boolean) pjp.proceed(pjp.getArgs()); } return b; }
四、使用AspectJ 简化AOP配置
Spring的AOP配置常有两种方式:
>通过schema形式实现简单AOP配置,也就是上面事例使用方法。
>使用annotation简化AOP配置。
AspectJ是一个面向切面的框架,AspectJ定义了AOP语法。
使用@AspectJ必须使用jdk5.0以上版本。
步骤:
1.编写业务类(与上面方法相同)。
2.编写切面类。
package com.jbit.ssh.aop;import org.aspectj.lang.annotation.After;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Before;@Aspect //1.通过注解标记一个切面public class AspectTest { @Before("execution(* com.jbit.ssh.service..*.*(..))")//2.定义切点和增强类型(切点表达式) public void ba(){ //3.增强处理的fun 4.配置
3.编写配置文件实现AOP
<? http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd" > <!--4.基于@AspectJ切面的驱动器 --> <aop:aspectj-autoproxy /> <bean ></bean></beans>
原标题:Spring核心概念之AOP
关键词:Spring