- 浏览: 235931 次
- 性别:
- 来自: 深圳
文章分类
最新评论
-
wahahachuang8:
GoEasy 实时推送支持IE6-IE11及大多数主流浏览器的 ...
服务器推送技术 java -
mahuanjian:
[flash=200,200][/flash]
服务器推送技术 java -
wenjundiandian:
下面有网页编辑器的话还是会被隐藏.
ext中消息框、提示框、确认框显示在最前面的解决方法 -
天塔上的猫:
/**
* JAVA常见的权限控制算法的实现
*
* ...
JAVA常见的权限控制算法的实现
来源:http://javacrazyer.iteye.com/blog/794143
AOP常用实现方式是一个采用声明的方式来实现,一个采用注解的方式来实现,
温习下一些概念
Joinpoint(连接点):程序执行时的某个特定的点,在Spring中就是某一个方法的执行
Pointcut(切点):说的通俗点,spring中AOP的切点就是指一些方法的集合,而这些方法
是需要被增强、被代理的。一般都是按照一定的约定规则来表示的,如正则表达式等。切点是
由一类连接点组成。
Advice(通知):还是说的通俗点,就是在指定切点上要干些什么。
Advisor(通知器):其实就是切点和通知的结合
第一种,为最基本的用法,大致步骤为:配置文件中配置pointcut, 在java中用编写实际的aspect 类, 针对对切入点进行相关的业务处理.
编写目标对象类(CommonEmployee.java),具体代码如下(省略接口类):
- <SPAN style="FONT-SIZE: medium">package com.aop;
- public class CommonEmployee implements Employee{
- private String name;
- public String getName() {
- return name;
- }
- public void setName(String name) {
- this.name = name;
- }
- public void signIn() {
- System.out.println(name+"已经签到了...........");
- }
- }</SPAN>
package com.aop;
public class CommonEmployee implements Employee{
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void signIn() {
System.out.println(name+"已经签到了...........");
}
}
具体通知类Logger.java如下:
- <SPAN style="FONT-SIZE: medium">package com.aop;
- import java.util.Date;
- import org.aspectj.lang.ProceedingJoinPoint;
- public class Logger{
- //spring中Before通知
- public void logBefore() {
- System.out.println("logBefore:现在时间是:....");
- }
- //spring中After通知
- public void logAfter() {
- System.out.println("logAfter:现在时间是:.....");
- }
- //spring中Around通知
- public Object logAround(ProceedingJoinPoint joinPoint) {
- System.out.println("logAround开始:现在时间是:....."); //方法执行前的代理处理
- Object[] args = joinPoint.getArgs();
- Object obj = null;
- try {
- obj = joinPoint.proceed(args);
- } catch (Throwable e) {
- e.printStackTrace();
- }
- System.out.println("logAround结束:现在时间是:....."); //方法执行后的代理处理
- return obj;
- }
- }</SPAN>
package com.aop;
import java.util.Date;
import org.aspectj.lang.ProceedingJoinPoint;
public class Logger{
//spring中Before通知
public void logBefore() {
System.out.println("logBefore:现在时间是:....");
}
//spring中After通知
public void logAfter() {
System.out.println("logAfter:现在时间是:.....");
}
//spring中Around通知
public Object logAround(ProceedingJoinPoint joinPoint) {
System.out.println("logAround开始:现在时间是:....."); //方法执行前的代理处理
Object[] args = joinPoint.getArgs();
Object obj = null;
try {
obj = joinPoint.proceed(args);
} catch (Throwable e) {
e.printStackTrace();
}
System.out.println("logAround结束:现在时间是:....."); //方法执行后的代理处理
return obj;
}
}
Spring配置
- <SPAN style="FONT-SIZE: medium"><bean id="employee" class="com.aop.CommonEmployee">
- <property name="name" value="good"></property>
- </bean>
- <bean id="advice" class="com.aop.Logger" />
- <aop:config >
- <aop:aspect ref="advice">
- <aop:pointcut id="pointcut" expression="execution(* com.aop.CommonEmployee.sign*(..))"/>
- <aop:before method="logBefore" pointcut-ref="pointcut"/>
- <aop:after method="logAfter" pointcut-ref="pointcut"/>
- <aop:around method="logAround" pointcut-ref="pointcut"/>
- </aop:aspect>
- </aop:config></SPAN>
<bean id="employee" class="com.aop.CommonEmployee">
<property name="name" value="good"></property>
</bean>
<bean id="advice" class="com.aop.Logger" />
<aop:config >
<aop:aspect ref="advice">
<aop:pointcut id="pointcut" expression="execution(* com.aop.CommonEmployee.sign*(..))"/>
<aop:before method="logBefore" pointcut-ref="pointcut"/>
<aop:after method="logAfter" pointcut-ref="pointcut"/>
<aop:around method="logAround" pointcut-ref="pointcut"/>
</aop:aspect>
</aop:config>
测试类
- <SPAN style="FONT-SIZE: medium">package com;
- import org.springframework.context.ApplicationContext;
- import org.springframework.context.support.ClassPathXmlApplicationContext;
- import com.aop.Employee;
- public class Test {
- public static void main(String[] args) throws Exception{
- ApplicationContext act = new ClassPathXmlApplicationContext("applicationContext-aop.xml");
- Employee e = (Employee)act.getBean("employee");
- e.signIn();
- }
- }</SPAN>
package com;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.aop.Employee;
public class Test {
public static void main(String[] args) throws Exception{
ApplicationContext act = new ClassPathXmlApplicationContext("applicationContext-aop.xml");
Employee e = (Employee)act.getBean("employee");
e.signIn();
}
}
测试结果
logBefore:现在时间是.....
logAround开始:现在时间是:....
good已经签到了...........
logAfter:现在时间是:...
logAround结束:现在时间是:......
第二种, 采用注解来做aop, 主要是将写在spring 配置文件中的连接点, 写到注解里面
首先,在spring配置文件中加入如下配置(用来申明spring对@AspectJ的支持):
<aop:aspectj-autoproxy/>
如果你使用的是DTD,可以在Spring配置文件中加入如下配置来申明spring对@Aspect的支
持:
<bean class="org.springframework.aop.aspectj.annotation.
AnnotationAwareAspectJAutoProxyCreator" />
目标对象类与上边一样
具体通知类如下
- <SPAN style="FONT-SIZE: medium">package com.aop;
- import java.util.Date;
- import org.aspectj.lang.ProceedingJoinPoint;
- import org.aspectj.lang.annotation.After;
- import org.aspectj.lang.annotation.Around;
- import org.aspectj.lang.annotation.Aspect;
- import org.aspectj.lang.annotation.Before;
- /**
- * 使用@Aspect 注解的类, Spring 将会把它当作一个特殊的Bean(一个切面),也就是
- * 不对这个类本身进行动态代理
- */
- @Aspect
- public class AspectJLogger {
- /**
- * 必须为final String类型的,注解里要使用的变量只能是静态常量类型的
- */
- public static final String EDP = "execution(* com.aop.CommonEmployee.sign*(..))";
- @Before(EDP) //spring中Before通知
- public void logBefore() {
- System.out.println("logBefore:现在时间是:......");
- }
- @After(EDP) //spring中After通知
- public void logAfter() {
- System.out.println("logAfter:现在时间是:.....");
- }
- @Around(EDP) //spring中Around通知
- public Object logAround(ProceedingJoinPoint joinPoint) {
- System.out.println("logAround开始:现在时间是:....."); //方法执行前的代理处理
- Object[] args = joinPoint.getArgs();
- Object obj = null;
- try {
- obj = joinPoint.proceed(args);
- } catch (Throwable e) {
- e.printStackTrace();
- }
- System.out.println("logAround结束:现在时间是:....."); //方法执行后的代理处理
- return obj;
- }
- }</SPAN>
package com.aop;
import java.util.Date;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
/**
* 使用@Aspect 注解的类, Spring 将会把它当作一个特殊的Bean(一个切面),也就是
* 不对这个类本身进行动态代理
*/
@Aspect
public class AspectJLogger {
/**
* 必须为final String类型的,注解里要使用的变量只能是静态常量类型的
*/
public static final String EDP = "execution(* com.aop.CommonEmployee.sign*(..))";
@Before(EDP) //spring中Before通知
public void logBefore() {
System.out.println("logBefore:现在时间是:......");
}
@After(EDP) //spring中After通知
public void logAfter() {
System.out.println("logAfter:现在时间是:.....");
}
@Around(EDP) //spring中Around通知
public Object logAround(ProceedingJoinPoint joinPoint) {
System.out.println("logAround开始:现在时间是:....."); //方法执行前的代理处理
Object[] args = joinPoint.getArgs();
Object obj = null;
try {
obj = joinPoint.proceed(args);
} catch (Throwable e) {
e.printStackTrace();
}
System.out.println("logAround结束:现在时间是:....."); //方法执行后的代理处理
return obj;
}
}
Spring的配置
- <SPAN style="FONT-SIZE: medium"> <aop:aspectj-autoproxy/>
- <bean id="aspect" class="com.aop.AspectJLogger" />
- <bean id="employee" class="com.aop.CommonEmployee">
- <property name="name" value="good"></property>
- </bean></SPAN>
<aop:aspectj-autoproxy/>
<bean id="aspect" class="com.aop.AspectJLogger" />
<bean id="employee" class="com.aop.CommonEmployee">
<property name="name" value="good"></property>
</bean>
测试类与上边一样
测试结果
logBefore:现在时间是:....
logAround开始:现在时间是:....
good已经签到了...........
logAfter:现在时间是:....
logAround结束:现在时间是:....
注意:
1.环绕方法通知,环绕方法通知要注意必须给出调用之后的返回值,否
则被代理的方法会停止调用并返回null,除非你真的打算这么做。
2.只有环绕通知才可以使用JoinPoint的子类ProceedingJoinPoint,个
连接点类型可以调用代理的方法,并获取、改变返回值。
发表评论
-
利用 Heritrix 构建特定站点爬虫
2011-01-12 13:42 895Heritrix 是一个由 java 开 ... -
java解析xml文件四种方式
2011-01-10 16:23 7661.介绍 1)DOM(JAXP Crims ... -
详解Java解析XML的四种方法
2010-12-09 22:31 850来源:http://mengsina.iteye.co ... -
(转载)手写压缩软件,超详细解释(哈夫曼实现)
2010-12-07 11:17 1098转载自:http://stchou.iteye.com/b ... -
java通过包装器防SQL注入
2010-01-29 11:04 1251定义包装器对request进行 ... -
comparable 与comparator的区别
2010-01-29 09:12 955Comparable & Comparator 都是用 ... -
Java经典问题算法大全
2010-01-28 20:52 3040/*【程序1】题目:古典 ... -
Java各种排序算法
2010-01-28 20:50 927/*** 排序测试类* * 排序算法的分类如下:* 1.插入排 ... -
Java细节总结
2010-01-28 20:46 707TURE、FALSE、NULL等都不是Java关键字; 数组 ... -
设计异常管理系统
2010-01-28 20:37 848——针对有效的错误处理设计异常管理系统 作者:Jean-Pie ... -
使用Filter快速对网页资源进行缓存
2010-01-28 20:18 898使用Filter快速对网页资源进行缓存,在网页资源没有改变的情 ... -
详解ThreadLocal与synchronized
2010-01-28 20:14 800Java良好的支持多线程。使用java,我们可以很轻松的编程一 ... -
在有多个选择路径的情况下,利用Switch可以使程序更加简洁有效。但由于其只能对整数选择因子进行判断,所以限制了其在其他类型尤其是String的使用,本文利用J
2010-01-28 20:04 887在有多个选择路径的情况下,利用Switch可以使程序更加简洁有 ... -
java优化编程37条
2010-01-28 20:00 7121.JVM管理两种类型的内 ... -
服务器推送技术 java
2009-12-28 12:11 6290下面介绍在ARP之上的一个非常热门的技术实现:服务器推送技术。 ... -
java排序集锦
2009-12-16 09:29 854Java代码 package sort; ... -
3DES加密解密调用示例
2009-12-15 10:02 994在java中调用sun公司提供的3DES加密解密算法时,需要使 ... -
java货币 Locale Currency NumberFormat
2009-12-04 18:14 2386使用java currency配合Locale,NumberF ... -
Deque 作为堆栈使用(ArrayDeque)
2009-12-04 18:09 2812package code.jdk; imp ... -
Random类
2009-12-04 14:00 1041Random类 (java.util) ...
相关推荐
在 Spring 中,AOP 的实现主要依赖于代理模式,有两种代理方式:JDK 动态代理和 CGLIB 动态代理。 JDK 动态代理是基于接口的,它要求被代理的目标对象必须实现至少一个接口。Spring 使用 `java.lang.reflect.Proxy`...
压缩包中的"aop"文件可能包含了一个简单的Spring AOP示例项目,包括了上述两种实现方式的源代码和配置文件。下载后,可以直接运行以观察AOP如何工作。 总结来说,Spring AOP提供了一种强大的方式来实现横切关注点,...
动态代理是实现AOP的一种常用技术,它允许在运行时创建代理对象,拦截对真实对象的调用,并在调用前后添加额外的行为。 在Java开发中,反射机制是实现动态代理的关键技术之一。反射提供了在运行时访问和操作类的...
Spring AOP主要通过两种方式实现:JDK动态代理和CGLIB代理。 - **JDK动态代理**: - 当目标对象实现了至少一个接口时,Spring会使用JDK的java.lang.reflect.Proxy类创建一个代理对象。 - 代理对象在调用实际方法...
在Spring AOP中,切面可以通过两种方式定义:使用注解或者XML配置。在这个例子中,我们可能会选择注解方式,因为它更简洁且易于理解。 1. **创建切面类(Aspect)** 我们可以创建一个名为`LoggingAspect`的Java类...
- **代理(Proxy)**:Spring AOP通过代理模式来实现切面功能,有JDK动态代理和CGLIB代理两种方式。 **2. JDK 动态代理** - 当目标类实现了接口时,Spring AOP会选择使用JDK动态代理。它会生成一个实现了目标类所有...
每种实现方式都有其适用场景和优缺点。基于代理的方式简单易懂,但受限于目标对象是否需要实现接口;AspectJ注解方式简化了代码,提高了可读性;XML配置提供了清晰的结构,适合大型项目;Java配置则结合了灵活性和可...
Spring支持两种AOP的实现方式:Spring AspectJ注解风格和Spring XML配置风格。使用AspectJ注解风格是最常见的,它允许开发者直接在方法上使用注解来定义切面。 Spring AOP中有五种不同类型的的通知(Advice): 1....
Spring AOP基于两种代理机制实现:JDK动态代理和CGLIB代理。JDK动态代理适用于实现了接口的目标对象,通过反射机制创建一个代理类来拦截方法调用。而CGLIB是在运行时动态生成一个目标类的子类,从而实现对方法的...
1. **静态代理**:Spring AOP 提供了两种代理方式,一种是静态代理,另一种是动态代理。静态代理是在编译时就确定了代理类,这种代理方式通常通过实现相同接口的方式创建。然而,Spring AOP默认并不使用静态代理,...
在Spring AOP中,切面主要通过两种方式实现:代理(Proxies)和织入(Weaving)。 1. **代理**:Spring AOP支持两种类型的代理:JDK动态代理和CGLIB代理。JDK代理用于实现了接口的类,而CGLIB代理则用于没有接口或...
Spring AOP的实现主要依赖于两种技术:动态代理和AspectJ。对于接口,Spring使用Java动态代理(JDK Proxy)创建代理对象;而对于类,Spring则使用CGLIB库生成子类代理。这两种方式都是在运行时生成代理对象,从而在...
总结一下,通过上述步骤,我们已经在Spring Boot应用中利用Spring AOP和注解方式实现了数据脱敏。这个拦截器可以在不修改原有业务代码的情况下,确保敏感信息在响应给客户端之前得到处理,提高了应用的安全性。同时...
1. **基于代理的AOP**:Spring提供了两种代理方式,JDK动态代理和CGLIB代理。JDK动态代理主要针对接口实现,而CGLIB代理则针对类实现。 2. **基于注解的AOP**:Spring 2.5开始支持注解驱动的AOP,通过在方法上使用`...
本文将详细解析Spring AOP的三种实现方式,帮助你深入理解这一重要概念。 首先,理解AOP的基本概念至关重要。AOP是一种编程范式,它允许开发者定义“切面”,即关注点的模块化,如日志、事务管理等。这些切面可以...
Spring AOP,全称Spring面向切面编程,是Spring框架中的一个重要组成部分,它提供了一种在不修改原有代码的情况下,对...了解并熟练掌握这两种配置方式,能够帮助我们更好地利用Spring AOP提高代码的可维护性和复用性。
动态代理则是Spring AOP实现的核心技术之一,它允许我们在运行时创建具有额外行为的对象。下面将详细阐述Spring AOP的配置以及动态代理的实现。 一、Spring AOP基础知识 1. **什么是AOP**:AOP是一种编程范式,...
1. 注解驱动的AOP:这是最常用的实现方式,通过在方法上添加注解(如`@Before`, `@After`, `@Around`, `@AfterReturning`, `@AfterThrowing`)来定义通知,并使用`@Aspect`注解定义切面。 2. XML配置驱动的AOP:...
Spring AOP提供了注解和XML两种方式来实现切面编程。注解方式更加简洁,易于理解和维护,适用于大多数情况。而XML配置方式则在复杂场景下更具灵活性,如需要动态调整切面配置时。在实际项目中,可以根据需求选择适合...
Spring AOP的实现方式主要有两种:静态代理和动态代理。静态代理是开发者手动创建代理类,而动态代理则是在运行时生成代理对象,这正是反射发挥作用的地方。在Java中,可以使用`java.lang.reflect.Proxy`类和`java....