`
lindongxiao
  • 浏览: 47616 次
  • 性别: Icon_minigender_1
  • 来自: 泉州
社区版块
存档分类
最新评论

aop 笔记 引入

    博客分类:
  • aop
阅读更多
引入和其它类型的spring通知有所不同.其它类型的通知是在方法调用的周围织入到不同的连接点.而引入则是影响整个类.
引入让你能动态地建立复合对象.
spring 通过一个特殊的方法拦截接口IntroductionInterceptor
                     
java 代码
 
  1. boolean implementsInterface(Class intf);  
  2. 这个方法判断是否是引入的接口  
要引入的接口
java 代码
 
  1. package aop.introduction;  
  2.   
  3. public interface IChange {  
  4.         public boolean ichange();  
  5. }  
现在我们实现一个introductionInterceptor
java 代码
 
  1. package aop.introduction;  
  2.   
  3. import org.aopalliance.intercept.MethodInvocation;  
  4. import org.springframework.aop.IntroductionInterceptor;  
  5.   
  6.   
  7. public class IChangeAdvisora implements IntroductionInterceptor,IChange{  
  8.   
  9.     public Object invoke(MethodInvocation m) throws Throwable {  
  10.         if(implementsInterface(m.getMethod().getDeclaringClass())){  
  11.             return m.getMethod().invoke(this, m.getArguments());
  12.             //通过MethodInvocation 和invoke代理要引入的方法
  13.         }else{  
  14.             return m.proceed();  //委托其它方法,不是引入,就像那个环绕通知
  15.         }  
  16.     }  
  17.   
  18.     public boolean implementsInterface(Class intf) {  
  19.         return intf.isAssignableFrom(IChange.class);  
  20.     }  
  21.   
  22.     public boolean ichange() {  
  23.         System.out.println("intrduction");  
  24.         return false;  
  25.     }  
  26.   
  27. }  
spring 为我们提供一个方便类的处理大多数的应用.DelegatingIntroductInterceptor
java 代码
 
  1. package aop.introduction;  
  2.   
  3. import org.springframework.aop.support.DelegatingIntroductionInterceptor;  
  4.   
  5. public class IChangeAdvisor extends DelegatingIntroductionInterceptor   
  6.                    implements IChange  {  
  7.   
  8.     public boolean ichange() {  
  9.         // TODO 自动生成方法存根  
  10.         System.out.println("ichage");  
  11.       
  12.         return false;  
  13.     }     
  14. }  //比起上面那个类算得比较简洁,DelegatingIntroductionInterceptor 替我们实现invoke()
如果你想实现方法的拦截调用invoke方法
java 代码
 
  1. package aop.introduction;  
  2.   
  3. import org.aopalliance.intercept.MethodInvocation;  
  4. import org.springframework.aop.support.DelegatingIntroductionInterceptor;  
  5.   
  6. public class IChangeAdvisorb extends DelegatingIntroductionInterceptor implements IChange {  
  7.   
  8.     public boolean ichange() {  
  9.         // TODO 自动生成方法存根  
  10.         return false;  
  11.     }  
  12.     public Object invoke(MethodInvocation e) throws Throwable{  
  13.         String name = e.getMethod().getName();  
  14.         if(name.indexOf("set") == 0){   //这里拦截set方法  
  15.             throw new IllegalMonitorStateException();  
  16.         }  
  17.         return super.invoke(e);  
  18.     }  
  19.   
  20. }  
下面是配制
java 代码
 
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">  
  3. <beans>  
  4.     <bean id="targetbean" class="aop.introduction.TagetBean" />  
  5.   
  6.     <bean id="iChangeAdvisor" class="aop.introduction.IChangeAdvisorb" />  
  7.  //这里配制引入advisor,看你用得是那个  
  8.     <bean id="advisor"  
  9.         class="org.springframework.aop.support.DefaultIntroductionAdvisor">  
  10.         <constructor-arg>  
  11.             <ref bean="iChangeAdvisor" />  
  12.         </constructor-arg>  
  13.     </bean>  
  14.     <bean id="bean"  
  15.         class="org.springframework.aop.framework.ProxyFactoryBean">  
  16.         <property name="target">  
  17.             <ref bean="targetbean" />  
  18.         </property>  
  19.         <property name="interceptorNames">  
  20.             <list>  
  21.                 <value>advisor</value>  
  22.             </list>  
  23.         </property>  
  24.         <property name="proxyInterfaces">  
  25.             <value>aop.introduction.IChange</value>  
  26.         </property>  
  27.         <property name="proxyTargetClass">  
  28.             <value>true</value>  
  29.         </property>  
  30.     </bean>  
  31. </beans>  
java 代码
 
  1. package aop.introduction;  
  2.   
  3. import org.springframework.context.ApplicationContext;  
  4. import org.springframework.context.support.FileSystemXmlApplicationContext;  
  5.   
  6. public class IntroductionTest {  
  7.   
  8.     public static void main(String[] args) {  
  9.         ApplicationContext ctx = new FileSystemXmlApplicationContext(  
  10.                 "./src/applicationContext.xml");  
  11.   
  12.         TagetBean bean = (TagetBean) ctx.getBean("bean");  
  13. //                 ((IChange) ctx.getBean("bean")).ichange();  
  14.        IChange mod = (IChange) bean;  
  15.   
  16.         // test interfaces  
  17.         System.out.println("Is TargetBean?: " + (bean instanceof TagetBean));  
  18.         System.out.println("Is IsModified?: " + (bean instanceof IChange));  
  19.   
  20.         // test is modified implementation  
  21. //        mod.ichange();  
  22.        // bean.setName("ddd");  
  23.         System.out.println("Has been modified?: " + mod.ichange());  
  24.     }  
  25. }             
  26.          
分享到:
评论
2 楼 songfuqiang 2008-07-04  
谢谢楼主,把代码复制下来就可以用了!
1 楼 lindongxiao 2007-07-16  
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="targetbean" class="aop.introduction.TagetBean" />

<bean id="iChangeAdvisor" class="aop.introduction.IChangeAdvisorb" />
<bean id="advisor"
class="org.springframework.aop.support.DefaultIntroductionAdvisor">
<constructor-arg>
<ref bean="iChangeAdvisor" />
</constructor-arg>
</bean>
<bean id="bean"
class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target">
<ref bean="targetbean" />
</property>
<property name="interceptorNames">
<list>
<value>advisor</value>
</list>
</property>
<property name="proxyInterfaces">
<value>aop.introduction.IChange</value>
</property>
<property name="proxyTargetClass">
<value>true</value>
</property>
</bean>
</beans>

相关推荐

    spring aop 学习笔记

    本学习笔记将深入探讨Spring AOP的核心概念、工作原理以及实际应用。 1. **核心概念** - **切面(Aspect)**:切面是关注点的模块化,包含业务逻辑之外的横切关注点,如日志、事务管理。 - **连接点(Join Point...

    SpringAop学习笔记以及实现Demo

    **Spring AOP 学习笔记及实现Demo** Spring AOP(Aspect Oriented Programming,面向切面编程)是Spring框架中的一个重要组成部分,它提供了一种在不修改源代码的情况下,对程序进行功能增强的技术。AOP的主要目的...

    Spring AOP IOC源码笔记.pdf

    本笔记将深入探讨这两个概念以及它们在Spring中的实现。 1. Spring框架简介: Spring作为一个轻量级的开源框架,旨在简化企业级应用的开发。它通过提供IOC容器,实现了对象的创建、管理和依赖注入,减轻了开发者对...

    spring ioc aop mvc boot-学习笔记.docx

    Spring Boot简化了Spring应用的配置,提供了自动配置特性,根据引入的依赖自动配置相应的bean。在`pom.xml`文件中,通过继承`spring-boot-starter-parent`父项目,可以避免手动管理依赖版本。`spring-boot-starter-...

    Spring AOP 用法笔记

    1. **注解驱动的AOP**:在Spring 2.5引入了基于注解的AOP,允许我们在切面类和方法上直接使用`@Aspect`、`@Before`、`@After`等注解,简化了配置。 2. **XML配置的AOP**:在Spring的XML配置文件中定义切面、通知、...

    Spring AOP 复习笔记.rar

    5. **引入(Introduction)**:允许向现有的类添加新的接口或方法,而无需修改源代码。 6. **织入(Weaving)**:将切面应用到目标对象来创建一个新的代理对象的过程。织入可以在编译时、类加载时或运行时完成。 #...

    spring ioc aop基础理论实践笔记

    ​ 非入侵式:就是项目引入了这个框架之后,(不会改变你代码原来的任何情况)不会对之前的代码有什么影响,反而是引入了之后会更加简单。 入侵式可以理解为为了引入一个jar包之前的代码不能用了。 3,控制反转...

    拿捏面试官-Spring AOP IOC源码笔记

    - **Spring AOP开发步骤**:引入AOP命名空间,使用注解或XML配置定义切面、切点和通知。 8. **JDBCTemplate和Spring事务** - **JdbcTemplate**:Spring提供的模板类,简化了JDBC操作,减少错误和冗余代码。 - **...

    Spring IOC和AOP代码与笔记整理

    1. 创建项目并引入Spring库。 2. 定义Bean类,使用`@Component`注解标记。 3. 使用`@Autowired`注解实现依赖注入。 4. 创建切面类,定义通知和切入点。 5. 配置Spring容器,可以是XML配置或使用`@Configuration`注解...

    学习Spring笔记_AOP_Annotation实现和XML实现

    Spring 2.5引入了基于注解的AOP支持,使得开发者可以直接在方法上声明切面,而无需编写XML配置。关键的注解包括: 1. `@Aspect`:定义一个切面类,该类包含了多个通知(advice)。 2. `@Before`:前置通知,方法在...

    Spring学习笔记(15)----使用Spring的注解方式实现AOP

    在本篇Spring学习笔记中,我们将深入探讨如何利用Spring框架的注解方式来实现面向切面编程(AOP)。AOP是一种编程范式,它允许我们定义横切关注点,如日志、事务管理等,然后将这些关注点模块化并插入到应用程序的多...

    基于SSM框架+mysql搭建的云笔记系统(仿有道云笔记)源码.zip

    其特性包括依赖注入(DI)、面向切面编程(AOP)、事务管理以及大量的可插入的数据访问抽象,如JDBC、Hibernate和iBatis。 2. **Spring MVC**:是Spring框架的一部分,专门用于构建Web应用。它提供了模型-视图-控制...

    达内java笔记,精挑细选(达内助教整理)0积分

    同时,Spring框架的引入让依赖注入和AOP(面向切面编程)成为可能,极大地简化了企业级应用的开发和管理。 此外,笔记中可能还会涉及Web服务,如SOAP(Simple Object Access Protocol)和RESTful API的设计,以及...

    宋红康java笔记.rar

    13. **Spring框架**:如果笔记涵盖了Spring,那么会讲解依赖注入、AOP、MVC等核心概念,这是Java开发中广泛使用的框架。 14. **单元测试**:JUnit是Java中的单元测试框架,学习如何编写测试用例,进行断言和异常...

    狂神笔记md文件. zip

    SpringBoot强调“约定优于配置”,减少了大量XML配置,鼓励使用starter依赖来快速引入所需功能。 这些笔记将涵盖这些框架的基本概念、配置、使用方法、最佳实践以及常见问题的解决,对于想要在Java后端领域深耕的...

    Spring笔记.doc

    2. 自动方式:引入 Spring 的 Web 包和 Struts 的 Spring 插件,配置监听器和应用上下文路径,让 Struts 从 Spring 容器中查找 Action 类,实现单例化,提高效率。 监听器如 ContextLoaderListener 在项目启动时...

    Android&Java; 技术笔记 等五本

    MVC模式是常见的架构设计,Spring框架提供了依赖注入和AOP等功能,简化了Java Web的开发。数据库连接管理涉及JDBC和ORM工具,如Hibernate,用于高效地操作数据库。 综上所述,这个压缩包包含的内容广泛且深入,适合...

    云笔记源码含数据库

    1. **Java (JDK1.5)**:Java是这个系统的基础编程语言,JDK1.5(Java Development Kit)引入了许多新特性,如自动装箱拆箱、泛型、枚举类型、变量枚举、静态导入等,提高了代码的可读性和可维护性。开发者可以通过这...

    javaweb笔记+狂神+知识总结

    5. **EL(Expression Language)**:EL是JSP 2.0引入的一种表达式语言,用于在JSP页面中访问JavaBean或其他Java对象的属性,简化了数据绑定的过程。 6. **Filter和Listener**:Filter用于拦截请求和响应,可以进行...

    Spring的学习笔记

    3. **引入jar包**:添加Spring的核心库和其他必要的依赖,例如Spring的IoC、AOP模块。 4. **测试代码**:编写测试类来验证配置是否正确,通常会使用`ApplicationContext`加载配置并获取bean。 5. **接口使用**:鼓励...

Global site tag (gtag.js) - Google Analytics