重新学习之spring第二个程序,配置AOP面向切面编程

简介: 第一步:在配置好的ioc容器的基础上,导入面向切面编程所需要的jar包 (本案例用的是spring3.2.4,由于spring3.2.4的官网jar包中不再有依赖包,所以依赖包都是从网上找的) 第二步:配置applicationContext.

第一步:在配置好的ioc容器的基础上,导入面向切面编程所需要的jar包

(本案例用的是spring3.2.4,由于spring3.2.4的官网jar包中不再有依赖包,所以依赖包都是从网上找的)

第二步:配置applicationContext.xml(包括ioc对象配置,以及面向切面编程的相关配置)

 

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4         xmlns:aop="http://www.springframework.org/schema/aop"
 5         xmlns:tx="http://www.springframework.org/schema/tx"
 6         xsi:schemaLocation="
 7             http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
 8             http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
 9             http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
10     
11     <!-- 
12         lazy-init:true 懒加载,初始ioc化容器的时候,不建立对象
13         lazy-init:false(默认) 不懒加载,初始化ioc容器的时候,就讲applicationContext.XML中所有配置的类的对象创建,并建立关系
14         scope:prototype每次取对应id的类的对象,都新创建一个
15         scope:singleton(默认)类似于单例模式,只要容器初始化一个类对象,以后所有的取用,都是取这一个
16       -->
17       
18       <!-- 通过setter方法,依赖注入对象。控制反转 -->
19     <bean id="userDao" class="com.bjsxt.shang.dao.UserDao" lazy-init="default" scope="singleton"></bean>
20     <bean id="MyAction" class="com.bjsxt.shang.action.MyAction" lazy-init="default" scope="prototype">
21         <property name="userDao" ref="userDao"></property>
22     </bean>
23     
24     
25     <!-- 定义一个切面(连接点,切入点,通知) -->
26     <bean id="log" class="com.bjsxt.shang.aop.LogTextAop"></bean>
27     <aop:config >
28         <!-- 切入点,将dao包下所有有参数或无参数传入的,有返回值或无返回值类型的公共方法,进行代理。 -->
29         <aop:pointcut expression="execution(public * com.bjsxt.shang.dao.*.*(..))" id="logCut"/>
30         <aop:pointcut expression="execution(public String com.bjsxt.shang.dao.*.*(..))" id="logCut2"/>
31         <aop:pointcut expression="execution(public * com.bjsxt.shang.dao.*.find*(..))" id="logCut3"/>
32         <!-- 通知,也就是代理对象中增强功能代码的编写 -->
33         <aop:aspect ref="log">
34             <!-- 代理,是为了抽出一些通用需求的功能,因此该属性指定的代理时调用增强功能的方法 -->
35             <!-- 连接点执行前或后,执行通用的代码 -->
36             <aop:before method="beforeRun1" pointcut-ref="logCut"/>
37             <aop:after method="afterRun2" pointcut-ref="logCut2"/>
38             <!-- 环绕通知,有参数的传递,可对参数传递进行处理 -->
39             <aop:around method="aroundRun" pointcut-ref="logCut3"/>
40         </aop:aspect>
41     </aop:config>
42     
43     
44     
45 </beans>
View Code

 

第三步:在appliactionContext.xml中指定的面向切面编程的代理切面类。

 

 1 package com.bjsxt.shang.aop;
 2 
 3 import java.util.Date;
 4 
 5 import org.aspectj.lang.ProceedingJoinPoint;
 6 
 7 import com.alibaba.fastjson.JSONObject;
 8 /**
 9  * 面向切面编程,是对一个集合的方法(切入点切中的符合表达式的所有方法)进行代理,也就是说在执行这些集合中的方法时,会执行该代理切面类中的相关指定方法,做到日志记录,增强功能,等等效果。
10  * 而且属于热插拔式的。像usb一样,可去掉,可插入。而不影响项目的主要功能
11 * @ClassName: LogTextAop 
12 * @Description: TODO(这里用一句话描述这个类的作用) 
13 * @author 尚晓飞
14 * @date 2014-8-29 下午2:55:38 
15 *
16  */
17 public class LogTextAop {
18     /**
19      * 连接点(方法)执行前执行该方法
20     * @Title: beforeRun1 
21     * @Description: TODO(这里用一句话描述这个方法的作用) 
22     * @return void    返回类型 
23     * @author 尚晓飞
24     * @date 2014-8-29 上午11:08:41
25      */
26     public void beforeRun1(){
27         System.out.println("LogTextAop.beforeRun1()连接点执行前,我执行了该方法。aop-----前---------");
28     }
29     /**
30      * 连接点(方法)执行后执行该方法
31     * @Title: afterRun2 
32     * @Description: TODO(这里用一句话描述这个方法的作用) 
33     * @return void    返回类型 
34     * @author 尚晓飞
35     * @date 2014-8-29 下午1:47:40
36      */
37     public void afterRun2(){
38         System.out.println("LogTextAop.afterRun2()连接点执行后,我执行了该方法、aop-----后--------");
39     }
40     
41     /**
42      * 连接点(方法)执行前后都会执行的方法
43     * @Title: aroundRun 
44     * @Description: TODO(这里用一句话描述这个方法的作用) 
45     * @param pjp
46     * @return
47     * @return Object    返回类型 
48     * @author 尚晓飞
49     * @date 2014-8-29 下午2:05:39
50      */
51     public Object aroundRun(ProceedingJoinPoint pjp){
52         //获取委托类方法传入的参数
53         Object[] objs=pjp.getArgs();
54         //获取委托类方法的名字
55         String methdoName=pjp.getSignature().getName();
56         //获取委托类的一个对象
57         Object object=pjp.getTarget();
58         
59         //生成一个jsonobject对象
60         JSONObject jsonObject=new JSONObject();
61         
62         try {
63                 if(!methdoName.startsWith("find")){
64                     System.out.println("LogTextAop.aroundRun(连接点执行前执行----aop-around---前)");
65                         Object obj=pjp.proceed();
66                     System.out.println("LogTextAop.aroundRun(连接点执行后执行----aop-around---后)");
67                     return obj;
68                 
69                 }else{
70                     System.out.println("LogTextAop.aroundRun(连接点执行前执行----aoparound---前)");
71                     System.out.println("LogTextAop.aroundRun(操作时间)"+new Date().toLocaleString());
72                     System.out.println("LogTextAop.aroundRun(操作类型)"+methdoName);
73                     System.out.println("LogTextAop.aroundRun(操作内容)"+jsonObject.toJSONString(objs));
74                     Object obj=pjp.proceed();
75                     System.out.println("LogTextAop.aroundRun(连接点执行后----aoparound----后)");
76                     return obj;
77                 }
78         } catch (Throwable e) {
79             e.printStackTrace();
80         }
81         return null;
82     }
83 
84 }
View Code

 

第四步:测试面向切面编程的demo(省去了action,dao包下的类的源代码)

 

 1 package com.bjsxt.shang.test;
 2 
 3 import org.springframework.context.ApplicationContext;
 4 import org.springframework.context.support.ClassPathXmlApplicationContext;
 5 
 6 import com.bjsxt.shang.action.MyAction;
 7 import com.bjsxt.shang.dao.UserDao;
 8 
 9 public class Test {
10     public static void main(String[] args) {
11         
12         
13     
14                 //官方推荐,建立xml文件,配置程序中对象,和建立对象间关系的是applicationContext.xml
15                 //平民版的xml是 beans.xml controller.xml dao.xml service.xml
16                 //获取解析,并依赖注入applicationContext.XML文件的ioc容器
17                 //ApplicationContext acIoc=new ClassPathXmlApplicationContext("applicationContext.xml");
18                 ApplicationContext ioc=new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml"});
19             
20                 
21                 //获取所有的ioc容器
22                 //BeanFactory是所有Spring Ioc容器的父接口
23                 //BeanFactory beanFactory=new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml"});
24                 
25                 UserDao dao=(UserDao)ioc.getBean("userDao");
26                 UserDao dao1=(UserDao) ioc.getBean("userDao");
27                 //测试IOC容器中生成的对象是不是单例的。
28                 System.out.println(dao==dao1);
29                 
30                 MyAction userAction=(MyAction) ioc.getBean("MyAction");
31                 //userAction.add();
32                 //userAction.lang();
33                 userAction.ds();
34     }
35 
36 }
View Code

 

测试截图

 

 

 

 

AOP介绍
   Aspect Oriented Programing 面向切面编程
    (1)如果说面向对象编程是关注将需求功能划分为不同的并且相对独立,封装良好的类,并让它们有着属于自己的行为,依靠继承和多态等来定义彼此的关系的话;
    (2)面向方面编程则是希望能够将通用需求功能从不相关的类当中分离出来,能够使得很多类共享一个行为,一旦发生变化,不必修改很多类,而只需要修改这个行为即 可。
  AOP主要应用于日志记录,性能统计,安全控制,事务处理等方面。
     (1)前面我们讲的struts2中的拦截器,就是AOP的一种实现!

AOP的内部实现都是通过动态代理来实现。动态代理有两种常见的方式:
  1.    JDK提供的代理生成方式(Proxy,  InvocationHandle)
  2.    cglib 类库(spring和hibernate使用它)

AOP基本概念
}    连接点(Joinpoint)
◦     在程序执行过程中某个特定的点,比如某方法调用的时候或者处理异常的时候。 在Spring AOP中,一个连接点 总是 代表一个方法的执行。
}    切入点(Pointcut)
◦    匹配连接点(Joinpoint)的断言(是一种连接点的条件,判断特征)。通知和一个切入点表达式关联,并在满足这个切入点的连接点上运行(例如,当执行某个特定名称的方法时)。切入点表达式如何和连接点匹配是AOP的核心:Spring缺省使用AspectJ切入点语法。
    -->public void com.bjsxt.dao.userDao.*.*()
              :所有userDao包下的无返回值,无参数传入的,公共方法
    -->public *()
              :所有的公共方法
    -->public void com.bjsxt.dao.userDao.*.(..)
              :所有userDao包下的有参传入的无返回值的,公共的方法。
}    通知(Advice)
◦    在切面的某个特定的连接点(Joinpoint)上执行的动作。通知有各种类型,其中包括“around”、“before”和“after”等通知。
增强功能的代码编写区 。如日志记录,访问控制,增强功能。
}    切面(Aspect)
◦    一个关注点的模块化,这个关注点可能会横切多个对象。
包含了:连接点、切入点、通知。可以通过@Aspect定义为一个类
}    目标对象(Target Object)
     说白话就是----》委托类
◦    被一个或者多个切面(aspect)所通知(advise)的对象。也有人把它叫做被通知(advised) 对象。
}    织入(Weaving)
        制作代理类,和代理对象的过程
◦    把切面(aspect)连接到其它的应用程序类型或者对象上,并创建一个被通知(advised)的对象。

通知的类型
}    前置通知(Before advice)
◦    在某连接点(join point)之前执行的通知,但这个通知不能阻止连接点前的执行(除非它抛出一个异常)。
}    返回后通知(After returning advice)
◦    在某连接点(join point)正常完成后执行的通知:例如,一个方法没有抛出任何异常,正常返回。
}    抛出异常后通知(After throwing advice)
◦    在方法抛出异常退出时执行的通知。
}    后通知(After (finally)advice)
◦    当某连接点退出的时候执行的通知(不论是正常返回还是异常退出)。
}    环绕通知(Around Advice)
◦    包围一个连接点(join point)的通知,如方法调用。这是最强大的一种通知类型。 环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。

 

相关文章
|
23天前
|
XML Java 数据格式
Spring IOC—基于XML配置Bean的更多内容和细节(通俗易懂)
Spring 第二节内容补充 关于Bean配置的更多内容和细节 万字详解!
131 18
Spring IOC—基于XML配置Bean的更多内容和细节(通俗易懂)
|
11天前
|
XML Java 测试技术
spring复习01,IOC的思想和第一个spring程序helloWorld
Spring框架中IOC(控制反转)的思想和实现,通过一个简单的例子展示了如何通过IOC容器管理对象依赖,从而提高代码的灵活性和可维护性。
spring复习01,IOC的思想和第一个spring程序helloWorld
|
11天前
|
设计模式 Java 测试技术
spring复习04,静态代理动态代理,AOP
这篇文章讲解了Java代理模式的相关知识,包括静态代理和动态代理(JDK动态代理和CGLIB),以及AOP(面向切面编程)的概念和在Spring框架中的应用。文章还提供了详细的示例代码,演示了如何使用Spring AOP进行方法增强和代理对象的创建。
spring复习04,静态代理动态代理,AOP
|
2天前
|
Java Spring 容器
Spring IOC、AOP与事务管理底层原理及源码解析
Spring框架以其强大的控制反转(IOC)和面向切面编程(AOP)功能,成为Java企业级开发中的首选框架。本文将深入探讨Spring IOC和AOP的底层原理,并通过源码解析来揭示其实现机制。同时,我们还将探讨Spring事务管理的核心原理,并给出相应的源码示例。
22 9
|
11天前
|
前端开发 Java Spring
关于spring mvc 的 addPathPatterns 拦截配置常见问题
关于spring mvc 的 addPathPatterns 拦截配置常见问题
|
24天前
|
Java 数据库连接 数据库
Spring基础3——AOP,事务管理
AOP简介、入门案例、工作流程、切入点表达式、环绕通知、通知获取参数或返回值或异常、事务管理
Spring基础3——AOP,事务管理
|
24天前
|
Java 数据库连接 Maven
Spring基础1——Spring(配置开发版),IOC和DI
spring介绍、入门案例、控制反转IOC、IOC容器、Bean、依赖注入DI
Spring基础1——Spring(配置开发版),IOC和DI
|
1月前
|
IDE Java 开发工具
还在为繁琐的配置头疼吗?一文教你如何用 Spring Boot 快速启动,让开发效率飙升,从此告别加班——打造你的首个轻量级应用!
【9月更文挑战第2天】Spring Boot 是一款基于 Spring 框架的简化开发工具包,采用“约定优于配置”的原则,帮助开发者快速创建独立的生产级应用程序。本文将指导您完成首个 Spring Boot 项目的搭建过程,包括环境配置、项目初始化、添加依赖、编写控制器及运行应用。首先需确保 JDK 版本不低于 8,并安装支持 Spring Boot 的现代 IDE,如 IntelliJ IDEA 或 Eclipse。
87 5
|
2月前
|
Java Spring XML
掌握面向切面编程的秘密武器:Spring AOP 让你的代码优雅转身,横切关注点再也不是难题!
【8月更文挑战第31天】面向切面编程(AOP)通过切面封装横切关注点,如日志记录、事务管理等,使业务逻辑更清晰。Spring AOP提供强大工具,无需在业务代码中硬编码这些功能。本文将深入探讨Spring AOP的概念、工作原理及实际应用,展示如何通过基于注解的配置创建切面,优化代码结构并提高可维护性。通过示例说明如何定义切面类、通知方法及其应用时机,实现方法调用前后的日志记录,展示AOP在分离关注点和添加新功能方面的优势。
40 0
|
2月前
|
Java Spring 开发者
解锁 Spring Boot 自动化配置的黑科技:带你走进一键配置的高效开发新时代,再也不怕繁琐设置!
【8月更文挑战第31天】Spring Boot 的自动化配置机制极大简化了开发流程,使开发者能专注业务逻辑。通过 `@SpringBootApplication` 注解组合,特别是 `@EnableAutoConfiguration`,Spring Boot 可自动激活所需配置。例如,添加 JPA 依赖后,只需在 `application.properties` 配置数据库信息,即可自动完成 JPA 和数据源设置。这一机制基于多种条件注解(如 `@ConditionalOnClass`)实现智能配置。深入理解该机制有助于提升开发效率并更好地解决问题。
50 0
下一篇
无影云桌面