基于Spring框架的切面编程
基于Spring框架的切面编程
拦截指定执行的方法,在方法执行前后做一些操作,防止你忘了什么操作,忘关流之类的,造成线程堵塞
AOP aspect orient programing 面向切面编程,这个demo是基于上一篇博客 Spring依赖注入的demo写的,要引入的jar包:
两种配置方式 一种基于注解 一种基于xml配置
SpringAop基于注解方式:
首先要配置aop的xml,要加入三行代码在application-context.xml的标签头
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd"
xmlns:aop="http://www.springframework.org/schema/aop
applicaiton-context.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"
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"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
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"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
>
<context:component-scan base-package="com.dengweiquan.**"/>
<bean id="user" class="com.dengweiquan.entity.User">
<!--Spring用运行时会通过这个配置文件,加载这个bean,用反射创建这个bean,我们就不用创建对象就可以用到这个属性了-->
<!--<constructor-arg type="int" value="12345"></constructor-arg>-->
<!--<constructor-arg type="java.lang.String" value="laowang"></constructor-arg> -->
<property name="id" value="12345"/>
<property name="name" value="laowang" />
</bean>
<bean id="fatherUser" class="com.dengweiquan.entity.UserFather">
<property name="fatherName" value="laodie"/>
<!--ref里面user的意思是 这个bean参考user的bean-->
<property name="user" ref="user"/>
</bean>
<bean id="user" class="com.dengweiquan.entity.User">
<!--Spring用运行时会通过这个配置文件,加载这个bean,用反射创建这个bean,我们就不用创建对象就可以用到这个属性了-->
<!--<constructor-arg type="int" value="12345"></constructor-arg>-->
<!--<constructor-arg type="java.lang.String" value="laowang"></constructor-arg> -->
<property name="id" value="12345"/>
<property name="name" value="laowang" />
</bean>
<bean id="fatherUser" class="com.dengweiquan.entity.UserFather">
<property name="fatherName" value="laodie"/>
<!--ref里面user的意思是 这个bean参考user的bean-->
<property name="user" ref="user"/>
</bean>
<!--<aop:aspectj-autoproxy/> 的意思是自动检测我们设置的切面,自动代理-->
<aop:aspectj-autoproxy/>
</beans>
<aop:aspectj-autoproxy/>
</beans>
UserController类:
@Controller
public class UserController {
@Controller
public class UserController {
@Autowired
private UserService userService;
private UserService userService;
public UserService getUserService() {
return userService;
}
return userService;
}
public void setUserService(UserService userService) {
this.userService = userService;
}
}
this.userService = userService;
}
}
User类:
public class User {
private int id;
private String name;
public class User {
private int id;
private String name;
public User(){
}
public User(int id, String name) {
this.id = id;
this.name = name;
}
public User(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
return id;
}
public void setId(int id) {
this.id = id;
}
this.id = id;
}
public String getName() {
return name;
}
return name;
}
public void setName(String name) {
this.name = name;
}
}
this.name = name;
}
}
UserFather类:
public class UserFather {
private String fatherName;
private User user;
public class UserFather {
private String fatherName;
private User user;
public String getFatherName() {
return fatherName;
}
return fatherName;
}
public void setFatherName(String fatherName) {
this.fatherName = fatherName;
}
this.fatherName = fatherName;
}
public User getUser() {
return user;
}
return user;
}
public void setUser(User user) {
this.user = user;
}
}
this.user = user;
}
}
UserService类:
@Service
public interface UserService {
public String say(String value);
@Service
public interface UserService {
public String say(String value);
}
UserServiceImpl类:
@Service()
public class UserServiceImpl implements UserService {
@Override
public String say(String value) {
System.out.println("成功运行"+value);
return "我是返回值";
}
}
@Override
public String say(String value) {
System.out.println("成功运行"+value);
return "我是返回值";
}
}
主函数:
public class Main {
public class Main {
public static void main(String[] args) {
//拿到spring上下文 就拿到spring的bean了
ApplicationContext context=new ClassPathXmlApplicationContext("./com/dengweiquan/resource/application-context.xml");
// UserFather userFather=(UserFather) context.getBean(UserFather.class);
// System.out.println(userFather.getFatherName());//输出12345
//spring注解方式注入 MVC model view controller
// @Service 业务逻辑
//@Component 公共组件
//@Controller 控制用户请求 springMVC
//拿到spring上下文 就拿到spring的bean了
ApplicationContext context=new ClassPathXmlApplicationContext("./com/dengweiquan/resource/application-context.xml");
// UserFather userFather=(UserFather) context.getBean(UserFather.class);
// System.out.println(userFather.getFatherName());//输出12345
//spring注解方式注入 MVC model view controller
// @Service 业务逻辑
//@Component 公共组件
//@Controller 控制用户请求 springMVC
UserController userController=context.getBean(UserController.class);
UserService service= userController.getUserService();
service.say("laowang");
}
}
创建一个名为aop的包 右键新建UserAspcet类
@Component
@Aspect //声明切面
public class UserAspect {
//设置切点 概念:告诉spring容器,aop是要在什么地方切入,是拦截什么方法?拦截那个包下面的方法?
// @Pointcut 里的value参数实际是个正则表达式 这个是个死套路,可以记下来
//execution(* com.dengweiquan.service.*.*(..)) 意思是*你要拦截的包.包下的所有类,所有类下的方法
//告诉切点 你要拦截那个地方的全部方法
@Pointcut(value = "execution(* com.dengweiquan.service.*.*(..))")
public void pointCut(){
@Component
@Aspect //声明切面
public class UserAspect {
//设置切点 概念:告诉spring容器,aop是要在什么地方切入,是拦截什么方法?拦截那个包下面的方法?
// @Pointcut 里的value参数实际是个正则表达式 这个是个死套路,可以记下来
//execution(* com.dengweiquan.service.*.*(..)) 意思是*你要拦截的包.包下的所有类,所有类下的方法
//告诉切点 你要拦截那个地方的全部方法
@Pointcut(value = "execution(* com.dengweiquan.service.*.*(..))")
public void pointCut(){
}
//advice 拦截前要干什么事情,什么时候干
@Before(value = "pointCut()")
public void doBefore(JoinPoint joinPoint){
//JoinPoint 是连接点(程序执行的点,拿到执行拦截的那个点的方法)
//拿到方法的名称
String name= joinPoint.getSignature().getName();
//拿到方法的参数
Object[] args= joinPoint.getArgs();
System.out.println(name+" "+args.toString()); //输出say [Ljava.lang.Object;@72d1ad2e
}
//执行成功 输出 成功运行laowang
//拦截后要干什么事情
@After(value = "pointCut()")
public void doAfter(JoinPoint joinPoint){
String name= joinPoint.getSignature().getName();
//拿到方法的参数
Object[] args= joinPoint.getArgs();
System.out.println(name); //输出say
}
//result是拿到方法的返回值
@AfterReturning(value = "pointCut()",returning ="result" )
public void afterReturning(JoinPoint joinPoint,Object result){
//advice 拦截前要干什么事情,什么时候干
@Before(value = "pointCut()")
public void doBefore(JoinPoint joinPoint){
//JoinPoint 是连接点(程序执行的点,拿到执行拦截的那个点的方法)
//拿到方法的名称
String name= joinPoint.getSignature().getName();
//拿到方法的参数
Object[] args= joinPoint.getArgs();
System.out.println(name+" "+args.toString()); //输出say [Ljava.lang.Object;@72d1ad2e
}
//执行成功 输出 成功运行laowang
//拦截后要干什么事情
@After(value = "pointCut()")
public void doAfter(JoinPoint joinPoint){
String name= joinPoint.getSignature().getName();
//拿到方法的参数
Object[] args= joinPoint.getArgs();
System.out.println(name); //输出say
}
//result是拿到方法的返回值
@AfterReturning(value = "pointCut()",returning ="result" )
public void afterReturning(JoinPoint joinPoint,Object result){
//拦截方法的返回值
System.out.println(result); //输出我是返回值
}
//抛异常的时候
@AfterThrowing()
public void afterThrowing(){
System.out.println(result); //输出我是返回值
}
//抛异常的时候
@AfterThrowing()
public void afterThrowing(){
}
//环绕通知 控制方法的执行
@Around(value = "pointCut()")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
//推进方法执行点 ProceedingJoinPoint 假如弄了环绕通知,不执行proceedingJoinPoint.proceed(); 就会拦截这个方法,就不输出成功运行laowang
//全程监控方法执
proceedingJoinPoint.proceed(); //输出成功运行laowang
//环绕通知 控制方法的执行
@Around(value = "pointCut()")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
//推进方法执行点 ProceedingJoinPoint 假如弄了环绕通知,不执行proceedingJoinPoint.proceed(); 就会拦截这个方法,就不输出成功运行laowang
//全程监控方法执
proceedingJoinPoint.proceed(); //输出成功运行laowang
}
}
}
SpringAop基于xml:
先创建Logger类:
public class Logger {
//设置为环绕通知
public void doLog(ProceedingJoinPoint proceedingJoinPoint){
try {
proceedingJoinPoint.proceed(); //不运行这句就不会输出成功运行laowang
} catch (Throwable throwable) {
throwable.printStackTrace();
}
}
}
application-context.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"
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"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
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"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
>
<context:component-scan base-package="com.dengweiquan.**"/>
<bean id="user" class="com.dengweiquan.entity.User">
<!--Spring用运行时会通过这个配置文件,加载这个bean,用反射创建这个bean,我们就不用创建对象就可以用到这个属性了-->
<!--<constructor-arg type="int" value="12345"></constructor-arg>-->
<!--<constructor-arg type="java.lang.String" value="laowang"></constructor-arg> -->
<property name="id" value="12345"/>
<property name="name" value="laowang" />
</bean>
<bean id="fatherUser" class="com.dengweiquan.entity.UserFather">
<property name="fatherName" value="laodie"/>
<!--ref里面user的意思是 这个bean参考user的bean-->
<property name="user" ref="user"/>
</bean>
<bean id="user" class="com.dengweiquan.entity.User">
<!--Spring用运行时会通过这个配置文件,加载这个bean,用反射创建这个bean,我们就不用创建对象就可以用到这个属性了-->
<!--<constructor-arg type="int" value="12345"></constructor-arg>-->
<!--<constructor-arg type="java.lang.String" value="laowang"></constructor-arg> -->
<property name="id" value="12345"/>
<property name="name" value="laowang" />
</bean>
<bean id="fatherUser" class="com.dengweiquan.entity.UserFather">
<property name="fatherName" value="laodie"/>
<!--ref里面user的意思是 这个bean参考user的bean-->
<property name="user" ref="user"/>
</bean>
<!--<aop:aspectj-autoproxy/> 的意思是自动检测我们设置的切面,自动代理-->
<!--<aop:aspectj-autoproxy/>-->
<!--<aop:aspectj-autoproxy/>-->
<bean id="loger" class="com.dengweiquan.aop.Logger"></bean>
<!--用xml的方式声明切面-->
<aop:config>
<!--ref里面填的是要参考的bean-->
<aop:aspect id="logAspect" ref="loger" >
<aop:around method="doLog" pointcut="execution(* com.dengweiquan.service.*.*(..))"/>
</aop:aspect>
</aop:config>
</beans>
项目目录结构: