- 浏览: 3011898 次
- 性别:
- 来自: 河南
文章分类
- 全部博客 (340)
- Java综合 (26)
- 程序人生 (53)
- RIA-ExtJS专栏 (18)
- RIA-mxGraph专栏 (4)
- RIA-Flex4专栏 (43)
- 框架-Spring专栏 (16)
- 框架-持久化专栏 (22)
- 框架-Struts2专栏 (11)
- 框架-Struts专栏 (12)
- SQL/NOSQL (12)
- 报表/图表 (2)
- 工作流 (5)
- XML专栏 (4)
- 日常报错解决方案 (5)
- Web前端-综合 (12)
- Web/JSP (14)
- Web前端-ajax专栏 (14)
- Web前端-JQuery专栏 (9)
- IDE技巧 (6)
- FILE/IO (14)
- 远程服务调用 (2)
- SSO单点登录 (2)
- 资源分享 (22)
- 云计算 (1)
- 项目管理 (3)
- php专栏 (1)
- Python专栏 (2)
- Linux (1)
- 缓存系统 (1)
- 队列服务器 (1)
- 网络编程 (0)
- Node.js (1)
最新评论
-
hui1989106a:
我的也不能解压,360和好压都试了,都不行
《Spring in Action》完整中文版分享下载 -
temotemo:
这些example有些过时了,官方建议使用HBase-1.0 ...
Java操作Hbase进行建表、删表以及对数据进行增删改查,条件查询 -
zy8102:
非常感谢~
HeadFirst系列之七:《深入浅出SQL》原版高清PDF电子书分享下载 -
zy8102:
重命名了一下搞定了
HeadFirst系列之七:《深入浅出SQL》原版高清PDF电子书分享下载 -
zy8102:
为什么下载以后老解压不了呢?
HeadFirst系列之七:《深入浅出SQL》原版高清PDF电子书分享下载
原理
AOP(Aspect Oriented Programming),也就是面向方面编程的技术。AOP基于IoC基础,是对OOP的有益补充。
AOP将应用系统分为两部分,核心业务逻辑(Core business concerns)及横向的通用逻辑,也就是所谓的方面Crosscutting enterprise concerns,例如,所有大中型应用都要涉及到的持久化管理(Persistent)、事务管理(Transaction Management)、安全管理(Security)、日志管理(Logging)和调试管理(Debugging)等。
AOP正在成为软件开发的下一个光环。使用AOP,你可以将处理aspect的代码注入主程序,通常主程序的主要目的并不在于处理这些aspect。AOP可以防止代码混乱。
Spring framework是很有前途的AOP技术。作为一种非侵略性的、轻型的AOP framework,你无需使用预编译器或其他的元标签,便可以在Java程序中使用它。这意味着开发团队里只需一人要对付AOP framework,其他人还是像往常一样编程。
AOP概念
让我们从定义一些重要的AOP概念开始。
— 方面(Aspect):一个关注点的模块化,这个关注点实现可能另外横切多个对象。事务管理是J2EE应用中一个很好的横切关注点例子。方面用Spring的Advisor或拦截器实现。
— 连接点(Joinpoint):程序执行过程中明确的点,如方法的调用或特定的异常被抛出。
— 通知(Advice):在特定的连接点,AOP框架执行的动作。各种类型的通知包括“around”、“before”和“throws”通知。通知类型将在下面讨论。许多AOP框架包括Spring都是以拦截器做通知模型,维护一个“围绕”连接点的拦截器链。
— 切入点(Pointcut):指定一个通知将被引发的一系列连接点的集合。AOP框架必须允许开发者指定切入点,例如,使用正则表达式。
— 引入(Introduction):添加方法或字段到被通知的类。Spring允许引入新的接口到任何被通知的对象。例如,你可以使用一个引入使任何对象实现IsModified接口,来简化缓存。
— 目标对象(Target Object):包含连接点的对象,也被称作被通知或被代理对象。
— AOP代理(AOP Proxy):AOP框架创建的对象,包含通知。在Spring中,AOP代理可以是JDK动态代理或CGLIB代理。
— 编织(Weaving):组装方面来创建一个被通知对象。这可以在编译时完成(例如使用AspectJ编译器),也可以在运行时完成。Spring和其他纯Java AOP框架一样,在运行时完成织入。
各种通知类型包括:
— Around通知:包围一个连接点的通知,如方法调用。这是最强大的通知。Aroud通知在方法调用前后完成自定义的行为,它们负责选择继续执行连接点或通过返回它们自己的返回值或抛出异常来短路执行。
— Before通知:在一个连接点之前执行的通知,但这个通知不能阻止连接点前的执行(除非它抛出一个异常)。
— Throws通知:在方法抛出异常时执行的通知。Spring提供强制类型的Throws通知,因此你可以书写代码捕获感兴趣的异常(和它的子类),不需要从Throwable或Exception强制类型转换。
— After returning通知:在连接点正常完成后执行的通知,例如,一个方法正常返回,没有抛出异常。
Around通知是最通用的通知类型。大部分基于拦截的AOP框架(如Nanning和Jboss 4)只提供Around通知。
如同AspectJ,Spring提供所有类型的通知,我们推荐你使用最为合适的通知类型来实现需要的行为。例如,如果只是需要用一个方法的返回值来更新缓存,你最好实现一个after returning通知,而不是around通知,虽然around通知也能完成同样的事情。使用最合适的通知类型使编程模型变得简单,并能减少潜在错误。例如,你不需要调用在around通知中所需使用的MethodInvocation的proceed()方法,因此就调用失败。
切入点的概念是AOP的关键,它使AOP区别于其他使用拦截的技术。切入点使通知独立于OO的层次选定目标。例如,提供声明式事务管理的around通知可以被应用到跨越多个对象的一组方法上。 因此切入点构成了AOP的结构要素。
拦截器(也称拦截机)
拦截机 (Interceptor), 是 AOP (Aspect-Oriented Programming) 的另一种叫法。AOP本身是一门语言,只不过我们使用的是基于JAVA的集成到Spring 中的 SpringAOP。同样,我们将通过我们的例子来理解陌生的概念。
接口类
package com.test.TestSpring3;
public interface UserService // 被拦截的接口
...{
public void printUser(String user);
}
实现类
package com.test.TestSpring3;
public class UserServiceImp implements UserService // 实现UserService接口
...{
public void printUser(String user) ...{
System.out.println("printUser user:" + user);// 显示user
}
}
AOP拦截器
package com.test.TestSpring3; import org.aopalliance.intercept.MethodInterceptor; import org.aopalliance.intercept.MethodInvocation; public class UserInterceptor implements MethodInterceptor // AOP方法拦截器 ...{ public Object invoke(MethodInvocation arg0) throws Throwable ...{ try ...{ if (arg0.getMethod().getName().equals("printUser")) // 拦截方法是否是UserService接口的printUser方法 ...{ Object[] args = arg0.getArguments();// 被拦截的参数 System.out.println("user:" + args[0]); arg0.getArguments()[0] = "hello!";// 修改被拦截的参数 } System.out.println(arg0.getMethod().getName() + "---!"); return arg0.proceed();// 运行UserService接口的printUser方法 } catch (Exception e) ...{ throw e; } } }
测试类
package com.test.TestSpring3; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.xml.XmlBeanFactory; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import org.springframework.context.support.FileSystemXmlApplicationContext; import org.springframework.core.io.ClassPathResource; import org.springframework.core.io.Resource; import org.springframework.web.context.support.WebApplicationContextUtils; public class TestInterceptor ...{ public static void main(String[] args) ...{ ApplicationContext ctx = new FileSystemXmlApplicationContext( "classpath:applicationContext.xml"); // ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); UserService us = (UserService) ctx.getBean("userService"); us.printUser("shawn"); } }
配置文件
<?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="userServiceImp"
class="com.test.TestSpring3.UserServiceImp" />
<bean id="userInterceptor" class="com.test.TestSpring3.UserInterceptor" />
<bean id="userService"
class="org.springframework.aop.framework.ProxyFactoryBean">
<!-- 代理接口 -->
<property name="proxyInterfaces">
<value>com.test.TestSpring3.UserService</value>
</property>
<!-- 目标实现类 -->
<property name="target">
<ref local="userServiceImp" />
</property>
<!-- 拦截器 -->
<property name="interceptorNames">
<list>
<value>userInterceptor</value>
</list>
</property>
</bean>
</beans>
输出:
user:shawn
printUser---!
printUser user:hello!
结论:调用方法的时候 传入的值被拦截修改了.
拦截器中的事务管理(事务拦截机)
如果不采用拦截机的机制时,在使用JDBC进行数据库访问时,存在两种情况:
自动提交模式是不被推荐的,因为每个操作都将产生一个事务点,这对于大的应用来说性能将受到影响;再有,对于常见的业务逻辑,这种模式显得无能为力。比如:
转帐,从A帐户取出100元,将其存入B帐户;如果在这两个操作之间发生了错误,那么用户A将损失了100元,而本来应该给帐户B的,却因为失败给了银行。
所以,建议在所有的应用中,如果使用 JDBC 都将不得不采用非自动提交模式(你们要能发现了在我们的 JDBC 那个例子中,我们采用的就是自动提交模式,我们是为了把精力放在JDBC上,而不是事务处理上),即我们不得不在每个方法中:
try {
// 在获得连接后,立即通过调用 setAutoCommit(false) 将事务处理置为非自动提交模式 // Prepare Query to fetch the user Information
pst = conn.prepareStatement(findByName);
// ... conn.commit();
} catch(Exception ex) {
conn.rollback();
throw ex;
}finally {
try {
// Close Result Set and Statement
if (rset != null) rset.close();
if (pst != null) pst.close();
} catch (Exception ex) {
ex.printStackTrace();
throw new Exception("SQL Error while closing objects = " + ex.toString());
}
}
这样代码在AOP的倡导者看来是“肮脏”的代码。他们认为,所有的与事务有关的方法都应当可以集中配置(见声明性事务控制),并自动拦截,程序应当关心他们的主要任务,即商业逻辑,而不应和事务处理的代码搅和在一起。
我先看看 Spring 是怎么做到拦截的:
Spring 内置支持的事务处理拦截机
这里因为要用到JpetStore项目中的代码,我们将 applicationContext.xml 全部内容列出:
<?xml version="1.0" encoding="UTF-8"?>
<!--
- Application context definition for JPetStore's business layer.
- Contains bean references to the transaction manager and to the DAOs in
- dataAccessContext-local/jta.xml (see web.xml's "contextConfigLocation").
Jpetstore 的应用上下文定义,包含事务管理和引用了在 dataAccessContext-local/jta.xml(具体使用了哪个要看 web.xml 中的 'contextConfigLocation' 的配置)中注册的DAO
-->
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
<!-- ========================= GENERAL DEFINITIONS ========================= -->
<!-- Configurer that replaces ${...} placeholders with values from properties files
占位符的值将从列出的属性文件中抽取出来
-->
<!-- (in this case, mail and JDBC related properties) -->
<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>WEB-INF/mail.properties</value>
<value>WEB-INF/jdbc.properties</value>
</list>
</property>
</bean>
<!-- MailSender used by EmailAdvice
指定用于发送邮件的 javamail 实现者,这里使用了 spring 自带的实现。此 bean 将被 emailAdvice 使用
-->
<bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
<property name="host" value="${mail.host}"/>
</bean>
<!-- ========================= BUSINESS OBJECT DEFINITIONS ======================== -->
<!-- 不需要,因为被 SpringMVC 的实现使用 Generic validator for Account objects, to be used for example by the Spring web tier -->
<bean id="accountValidator" class="org.springframework.samples.jpetstore.domain.logic.AccountValidator"/>
<!-- 不需要,因为被 SpringMVC 的实现使用 Generic validator for Order objects, to be used for example by the Spring web tier -->
<bean id="orderValidator" class="org.springframework.samples.jpetstore.domain.logic.OrderValidator"/>
<!--
主要的商业逻辑对象,即我们所说的门面对象
注入了所有的DAO,这些DAO是引用了 dataAccessContext-xxx.xml 中定义的DAO
门面对象中的所有方法的事务控制将通过下面的 aop:config 来加以控制
- JPetStore primary business object (default implementation).
- Transaction advice gets applied through the AOP configuration below.
-->
<bean id="petStore" class="org.springframework.samples.jpetstore.domain.logic.PetStoreImpl">
<property name="accountDao" ref="accountDao"/>
<property name="categoryDao" ref="categoryDao"/>
<property name="productDao" ref="productDao"/>
<property name="itemDao" ref="itemDao"/>
<property name="orderDao" ref="orderDao"/>
</bean>
<!-- ========================= ASPECT CONFIGURATION ======================== -->
<!-- AOP配置,用来控制哪些方法将需要进行事务处理,采用了AspectJ 的语法 -->
<aop:config>
<!--
This definition creates auto-proxy infrastructure based on the given pointcut,
expressed in AspectJ pointcut language. Here: applying the advice named
"txAdvice" to all methods on classes named PetStoreImpl.
-->
<!-- 指出在 PetStoreFacade 的所有方法都将采用 txAdvice(在紧接着的元素中定义了)事务方针,注意,我们这里虽然指定的是接口 PetStoreFacace, 但其暗示着其所有的实现类也将
同样具有这种性质,因为本身就是实现类的方法在执行的,接口是没有方法体的。 -->
<aop:advisor pointcut="execution(* *..PetStoreFacade.*(..))" advice-ref="txAdvice"/>
<!--
This definition creates auto-proxy infrastructure based on the given pointcut,
expressed in AspectJ pointcut language. Here: applying the advice named
"emailAdvice" to insertOrder(Order) method of PetStoreImpl
-->
<!-- 当执行 PetStoreFacade.insertOrder方法,该方法最后一个参数为Order类型时(其实我们的例子中只有一个 insertOrder 方法,但这告诉了我们,当我们的接口或类中有重载了的方法,
并且各个重载的方法可能使用不同的拦截机机制时,我们可以通过方法的参数加以指定),将执行emailAdvice(在最后定义的那个元素)-->
<aop:advisor pointcut="execution(* *..PetStoreFacade.insertOrder(*..Order))" advice-ref="emailAdvice"/>
</aop:config>
<!--
事务方针声明,用于控制采用什么样的事务策略
Transaction advice definition, based on method name patterns.
Defaults to PROPAGATION_REQUIRED for all methods whose name starts with
"insert" or "update", and to PROPAGATION_REQUIRED with read-only hint
for all other methods.
-->
<tx:advice id="txAdvice">
<tx:attributes>
<tx:method name="insert*"/>
<tx:method name="update*"/>
<tx:method name="*" read-only="true"/>
</tx:attributes>
</tx:advice>
<!-- 拦截机,用于在适当的时机(通过AOP配置,如上面)在方法执行成功后发送邮件
AOP advice used to send confirmation email after order has been submitted -->
<!-- -->
<bean id="emailAdvice" class="org.springframework.samples.jpetstore.domain.logic.SendOrderConfirmationEmailAdvice">
<property name="mailSender" ref="mailSender"/>
</bean>
<!-- ========================= 忽略 REMOTE EXPORTER DEFINITIONS ======================== -->
</beans>
这个配置比想象的要简单的多:
<aop:config>
<!-- This definition creates auto-proxy infrastructure based on the given pointcut, expressed in AspectJ pointcut language.
Here: applying the advice named "txAdvice" to all methods on classes named PetStoreImpl. 指出在 PetStoreFacade
的所有方法都将采用 txAdvice(在紧接着的元素中定义了)事务方针,注意,我们这里虽然指定的是接口 PetStoreFacace,
但其暗示着其所有的实现类也将同样具有这种性质,因为本身就是实现类的方法在执行的,接口是没有方法体的。 -->
<aop:advisor pointcut="execution(* *..PetStoreFacade.*(..))" advice-ref="txAdvice"/>
<!-- 其它拦截机-->
</aop:config>
1. 所有的拦截机配置都放在 <aop:config> 配置元素中.
2. 下面还是需要理解一下几个有关AOP的专用名词,不过,是挺抽象的,最好能会意出其的用意
- pointcut 切入点,比如:updateAccount 方法需要进行事务管理,则这个切入点就是“执行方法体”(execution)。Spring 所有支持的切入点类型在都在 Spring reference: 6.2.3.1. Supported Pointcut Designators 中列出了。
- advice 要对这个切入点进行什么操作,比如事务控制
- advisor Spring 特有的概念,将上两个概念合到一个概念中来,即一个 advisor 包含了一个切入点及对这个切入点所实施的操作。
因为 方法执行切入点 execution 为最常见的切入点类型,我们着重介绍一下,execution 的完全形式为:
execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)
这是一个正则表达式,其中由 '?' 结尾的部分是可选的。翻译过来就是:
执行(方法访问修饰符? 方法返回类型 声明类型? 方法名(方法参数类型) 抛出异常?)
所有的这些都是用来定义执行切入点,即那些方法应该被侯选为切入点:
- 方法访问修饰符 即 public, private 等等
- 方法返回类型 即方法返回的类型,如 void, String 等等
- 声明类型 1.5的语法,现在可以先忽略它
- 方法名 方法的名字
- 方法参数类型 方法的参数类型
- 抛出异常 方法声明的抛出的异常
例如,所有dao代码被定义在包 com.xyz.dao 及子包 com.xyz.dao.hibernate, 或者其它,如果还有的话,子包中, 里面定义的是提供DAO功能的接口或类,那么表达式:
execution(* com.xyz.dao..*.*(..))
表示切入点为:执行定义在包 com.xyz.dao 及其子包(因为 .. 所致) 中的任何方法
详细情况可以参见 Spring refernce: 6.2.3.4. Examples
因此这个表达式为执行定义在类 PetStoreFacade 及其实现类中的所有方法,采取的动作定义在 txAdvice 中. 关于该 advice 的定义,(见声明性事务控制)一节
<aop:advisor pointcut="execution(* *..PetStoreFacade.*(..))" advice-ref="txAdvice"/>
Spring 自定拦截机
来为了进行事务控制,我们只需简单地配置几下,所有的工作都由 Spring 来做。这样固然很好,但有时我们需要有我们特有的控制逻辑。因为Spring 不可能包含所有人需要的所有拦截机。所以它提供了通过程序的方式加以定制的方式。我们的项目中就有这么一个拦截机,在用户确认付款后,将定单信息通过 email 的方式发送给注册用户的邮箱中。
<aop:config> ... <!-- 当执行 PetStoreFacade.insertOrder方法,该方法最后一个参数为Order类型时(其实我们的例子中只有一个 insertOrder 方法,但这告诉了我们,当我们的接口或类中有重载了的方法,
并且各个重载的方法可能使用不同的拦截机机制时,我们可以通过方法的参数加以指定),将执行emailAdvice(在最后定义的那个元素)--> <aop:advisor pointcut="execution(* *..PetStoreFacade.insertOrder(*..Order))" advice-ref="emailAdvice"/> </aop:config>
红色的注释已经说的很清楚这个 Advisor 了,它的切入点(pointcut) 为 PetStoreFacade 的 void insertOrder(Order order) 方法,采取的动作为引用的 emailAdvice, 下面我们就来看看 emailAdvice:
<bean id="emailAdvice" class="org.springframework.samples.jpetstore.domain.logic.SendOrderConfirmationEmailAdvice">
<property name="mailSender" ref="mailSender"/>
</bean>
它给了这个 advice 的实现类为 logic 包中 SendOrderConfirmationEmailAdvice, 该Bean 引用了我们前面定义的邮件发送器(一个 Spring 内置的邮件发送器).
下面看看这个实现类:
public class SendOrderConfirmationEmailAdvice implements AfterReturningAdvice, InitializingBean {
// user jes on localhost
private static final String DEFAULT_MAIL_FROM = "test@pprun.org";
private static final String DEFAULT_SUBJECT = "Thank you for your order!";
private final Log logger = LogFactory.getLog(getClass());
private MailSender mailSender;
private String mailFrom = DEFAULT_MAIL_FROM;
private String subject = DEFAULT_SUBJECT;
public void setMailSender(MailSender mailSender) {
this.mailSender = mailSender;
}
public void setMailFrom(String mailFrom) {
this.mailFrom = mailFrom;
}
public void setSubject(String subject) {
this.subject = subject;
}
public void throws Exception {
if (this.mailSender == null) {
throw new IllegalStateException("mailSender is required");
}
}
/**
*
* @param returnValue 被拦截的方法的返回值
* @param m 被拦截的方法的所有信息(Method类封装了这些信息)
* @param args 被拦截的方法的所有参数组成的数组
* @param target 目标对象,对于方法执行来说,即是方法所在的类的实例(与 this 同,批当前对象)
* @throws java.lang.Throwable
*/
public void afterReturning(Object returnValue, Method m, Object[] args, Object target) throws Throwable {
// 我们被拦截的方法为 void insertOrder(Order order),方法只有一个参数,所以可知数据的第1个元素即是被传进的 order 对象
// 得到了order 对象,就可以将 order 对应的帐户名及帐单号发送到邮件中,以便确认无误。
Order order = (Order) args[0];
Account account = ((PetStoreFacade) target).getAccount(order.getUser().getUsername());
// don't do anything if email address is not set
if (account.getEmail() == null || account.getEmail().length() == 0) {
return;
}
StringBuffer text = new StringBuffer();
text.append("Dear ").append(account.getFirstname()).
append(' ').append(account.getLastname());
text.append(", thank your for your order from JPetStore. " +
"Please note that your order number is ");
text.append(order.getId());
SimpleMailMessage mailMessage = new SimpleMailMessage();
mailMessage.setTo(account.getEmail());
mailMessage.setFrom(this.mailFrom);
mailMessage.setSubject(this.subject);
mailMessage.setText(text.toString());
try {
this.mailSender.send(mailMessage);
} catch (MailException ex) {
// just log it and go on
logger.warn("An exception occured when trying to send email", ex);
}
}
}
1. 红色的内容即为反向注入的 mailSender 属性
2. 蓝色的内容为 Spring Bean 的一个通用的接口 InitializingBean ,实现类需要实现该接口定义的方法 afterPropertiesSet() ,该方法中一般是在Bean 被初始化后并设置了所有的 setter 注入后调用的。所以这里是保证邮件发送器配置正确。因为如果没有配置正确,下面的工作是无法进行的,所以与其等那时抛出异常,还不如早早地在部署时就告知(通过抛出 IllegalStateException 来提示)
3. 绿色的内容为这个 Advise 的核心,即在切入点被切入后将采用的动作。因为 Advise 也同样有多种类型,比如我们这里的“方法正常返回”,“方法执行前”,“方法执行后”,“环绕在方法执行前后”,“方法抛出异常时”等等(详情参见 Spring Reference: 6.2.4. Declaring advice)。但是我们的逻辑为在用户确认定单并且执行成功(所谓的成功是指将这一定单插入到了表 Order 中了)后,将发送一确认信。所以”方法正常返回“完全符合我们的要求。
接口AfterReturningAdvice 即是 Spring中表示”方法正常返回“ 这一语义的 Advice, 所以我们实现这个接口及其必须的方法 afterReturning.
方法代码的工作其实并不重要,只要我们理解这些“魔法”一样的技术后,实现代码是很简单的。值得提及的是这个方法的参数,这些参数是封装了切入点的所有信息,请见上面的注释。在我们的实现中只使用了被拦截方法的参数,在复杂的 Advice 实现中可能会用到切入点所有信息。
评论
首先你要理解动态代理是种设计模式,而动态代理的设计模式又运动到了JDK的反射机制。那么拦截器就是使用动态代理的设计模式和JDK的反射机制
拦截器是通过代理来实现的。
恩恩
恩,一定要静下心来学习知识
的确是这样
发表评论
-
Spring温习(9)--配置hibernate信息
2010-11-04 09:45 3118有时候为了为了操作方便,我们时常在spring整合hibern ... -
Spring温习(8)--国际化的支持
2010-11-03 11:07 3797我今天介绍的国际化呢,平时基本上都用不上,我的项目中也从来没用 ... -
Spring温习(7)--有关定时任务Quartz的示例
2010-11-02 23:07 2834实际项目中有关定时任务的使用还是比较普遍的,比如定时做报表,定 ... -
Spring温习(6)--邮件发送实现
2010-10-28 21:55 7682Spring对邮件发送支持的很好,我们只要配置好邮件发送器,写 ... -
Spring温习(5)--CGLIB的动态代理[附AOP内部实现讲解]
2010-10-27 14:55 8885这篇文章紧接着上一篇静态代理和动态代理来说 前言: 到现在 ... -
Spring温习(4)--静态代理和动态代理
2010-10-27 11:27 3342代理模式分为静态代理和动态代理。静态代理就是我们自己定义的代理 ... -
Spring温习(3)--AutoWire自动装配
2010-10-27 09:48 3110在应用中,我们常常使用<ref>标签为JavaBe ... -
Spring温习(2)--IOC容器
2010-10-27 09:10 30531. Spring IoC的依赖注入 1) 使用构造方法来注入 ... -
Spring温习(1)--最基础的示例
2010-10-26 21:37 3499从现在开始,我将从Spring为起点,逐步复习几大框架各方面的 ... -
Spring事务管理的两种方式
2010-10-26 17:27 4037目前项目开发过程中对于Spring的事务管理,主要就这么两种方 ... -
Spring数据源配置的三种方式
2010-10-26 15:25 3786spring数据源配置目前确切的说应该分为:spring容器自 ... -
Spring AOP的两种实现方式
2010-10-26 11:18 5838AOP常用实现方式是一个采用声明的方式来实现,一个采用注解的方 ... -
在MyEclipse8.5中恢复jpetstore项目
2010-10-22 17:24 2326恢复jpetstore项目的过程1.在myeclipse8.5 ... -
SpringMVC关键问题讲解
2010-10-21 21:31 22934接着上篇文章,大家可能关心的那两个问题 1.control ... -
SpringMVC入门实例及详细讲解
2010-10-21 20:48 215130Spring 框架提供了构建 Web 应用程序的 ...
相关推荐
在Spring中,拦截器通常与通知概念一起使用,形成一个拦截器链,每个拦截器都可以在调用前后进行操作,且可以决定是否继续调用下一个拦截器或中断调用。 总之,Spring AOP通过面向切面编程提供了优雅的解决方案,将...
Spring AOP使用拦截器(Interceptor)机制来实现通知,拦截器按照顺序形成一个链,当目标方法被调用时,会逐个执行这些拦截器。这种设计使得我们可以灵活地插入、移除和重新排列通知,而不会影响核心业务代码。 ...
Spring AOP的实现主要依赖于拦截器(Interceptor)。拦截器在方法调用前后执行,形成一个拦截器链。通过定义拦截器,开发者可以定义在何时何地执行特定的逻辑,而无需直接修改原始业务代码。这极大地增强了代码的...
这将设置Spring Web相关类的日志级别为DEBUG,以便我们能看到拦截器的执行过程。 启动类通常会包含`@SpringBootApplication`注解,该注解包含了`@EnableAutoConfiguration`,`@ComponentScan`和`@...
SpringP原理及拦截器文档的主要内容涉及到Spring框架的核心技术,尤其是其中的AOP(面向切面编程)概念,以及Spring AOP的具体实现。文中提到了多个与AOP相关的关键点,包括事务管理、日志记录、调试、切面、切点、...
在Spring AOP中,拦截器调用的实现是通过动态代理机制来完成的,主要涉及到JDK的Proxy类和InvocationHandler接口。本文将详细解析Spring AOP如何利用这两个组件来实现拦截器链的调用。 首先,Spring在生成代理对象...
本例提供了一个简单的AOP拦截器实现,我们可以从这个基础出发,深入理解和探讨AOP的核心概念、工作原理以及其在实际开发中的应用。 首先,AOP的主要目标是解决程序中的横切关注点,如日志记录、事务管理、性能监控...
例如,可能会有一个自定义的MyBatis拦截器用于分页查询,一个Spring AOP切面用于记录操作日志,Spring事务管理确保数据的一致性,而反射工具类可能用于动态加载配置或处理某些通用的反射任务。通过这些组件的组合,...
它定义了一些通用的AOP接口,比如`org.aopalliance.intercept.MethodInterceptor`和`org.aopalliance.intercept.MethodInvocation`,使得不同的AOP框架(如Spring和AspectJ)可以共享相同的拦截器(interceptors)。...
Spring AOP 拦截器 Advisor 是 Spring 框架中的一个重要概念,它与切面编程密切相关,用于实现细粒度的控制和增强应用程序的行为。在 Spring AOP 中,Advisor 是一个组合了通知(Advice)和切入点(Pointcut)的对象...
具体到Spring AOP拦截器的代码实现,本文通过创建TestInterceptor类来演示。这个类继承自HandlerInterceptorAdapter,然后重写其中的afterCompletion、postHandle等方法。在这个类中,可以在相应方法中添加自定义的...
本实例主要探讨如何在Spring AOP中实现拦截器。 首先,我们来理解Spring AOP的基本概念。AOP的核心是代理,Spring提供了两种代理方式:JDK动态代理和CGLIB代理。JDK动态代理基于接口,当目标对象实现了接口时使用;...
总结来说,Spring AOP的日志拦截通过定义拦截器、切入点和顾问,可以方便地实现对特定方法的透明日志记录。这个示例中的`LogInterceptor.java`实现了具体拦截逻辑,而`config.xml`则负责配置拦截规则,两者结合实现...
标题中的“在自定义Spring AOP中使用EL获取拦截方法的变量值”指的是在Spring的面向切面编程(AOP)中,通过Expression Language(EL,表达式语言)来访问被拦截方法的局部变量值。这通常涉及到Spring的代理机制、...
本篇文章将深入探讨如何使用Spring AOP实现性能监控器,并通过源码分析来理解其工作原理。 首先,我们要了解AOP的核心概念——切面(Aspect)、通知(Advice)、连接点(Join Point)、切入点(Pointcut)和织入...
Spring AOP,全称Aspect-Oriented Programming(面向切面编程),是Spring框架的一个重要模块,它通过提供声明式的方式来实现面向切面编程,从而简化了应用程序的开发和维护。在Spring AOP中,我们无需深入到每个...
在提供的压缩包中,可能包含了一个或多个测试类(Tests),这些测试类通常用来验证AOP拦截器的功能。它们可能包含模拟业务场景的方法,这些方法会被切面拦截并执行相应的通知。通过运行这些测试,我们可以确保AOP...
### Spring AOP 四种创建通知(拦截器)类型详解 Spring AOP(Aspect Oriented Programming,面向切面编程)是Spring框架中的一个重要模块,它提供了在应用代码中添加横切关注点的能力,如日志记录、事务管理、权限...
现在让我们深入探讨JDK动态代理和Spring AOP的原理。 首先,JDK动态代理基于Java的反射机制,通过`java.lang.reflect.Proxy`类和`java.lang.reflect.InvocationHandler`接口来实现。Proxy类用于创建一个代理对象,...
在本项目中,我们将探讨如何通过配置文件实现Spring AOP,包括前置通知、后置通知以及拦截器的运用。 首先,我们需要理解Spring AOP的核心概念。切面(Aspect)是关注点的模块化,这些关注点定义了跨越多个对象的...