`
啸笑天
  • 浏览: 3466109 次
  • 性别: Icon_minigender_1
  • 来自: China
社区版块
存档分类
最新评论

Spring aop 简单总结

阅读更多

先用jdk,cglib模拟下:

使用JDK动态代理

//当目标类实现了接口,我们可以使用jdkProxy来生成代理对象。

 

package cn.zyj15.aop;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import cn.zyj15.service.impl.PersonServiceBean;
/**
 * 
 * @author Administrator
 *实现InvocationHandler接口的即为代理,记实现invoke方法
 */
public class JDKProxyFactory implements InvocationHandler {
    private Object targetObject;
	
	public Object createProxyIntance(Object targetObject){
		this.targetObject = targetObject;
		//从newProxyInstance方法看出用jdk实现代理必须实现接口
		/*
		* 第一个参数设置代码使用的类装载器,一般采用跟目标类相同的类装载器
		* 第二个参数设置代理类实现的接口
		* 第三个参数设置回调对象,当代理对象的方法被调用时,会委派给该参数指定对象的invoke方法
		*/
		return Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(), 
				this.targetObject.getClass().getInterfaces(), this);
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {//环绕通知
		PersonServiceBean bean = (PersonServiceBean) this.targetObject;
		Object result = null; 
		if(bean.getUser()!=null){
			//..... advice()-->前置通知
			try {
				result = method.invoke(targetObject, args);//把方法调用委派给目标对象
				// afteradvice() -->后置通知
			} catch (RuntimeException e) {
				//exceptionadvice()--> 例外通知
			}finally{
				//finallyadvice(); -->最终通知
			}
		}else {
			System.out.println("没有权限!");
		}
		return result;
	}

}

 

 

package junit.test15;

import static org.junit.Assert.*;
import org.junit.Test;
import cn.zyj15.aop.JDKProxyFactory;
import cn.zyj15.service.PersonService;
import cn.zyj15.service.impl.PersonServiceBean;

public class AOPTest {

	@Test
	public void jdktest() {
		JDKProxyFactory factory = new JDKProxyFactory();
		//必须用接口
		PersonService service = (PersonService) factory.createProxyIntance(new PersonServiceBean(null));
		service.save("888");
	}

}
 

使用CGLIB生成代理

//CGLIB可以生成目标类的子类,并重写父类非final修饰符的方法。

 

package cn.zyj16.aop;

import java.lang.reflect.Method;
import cn.zyj16.service.impl.PersonServiceBean;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CGlibProxyFactory implements MethodInterceptor{
	private Object targetObject;//代理的目标对象	
	
	public Object createProxyIntance(Object targetObject){
		this.targetObject = targetObject;
		Enhancer enhancer = new Enhancer();//该类用于生成代理对象
		enhancer.setSuperclass(this.targetObject.getClass());//设置代理类的父类。CGLIB可以生成目标类的子类,并重写父类非final修饰符的方法。
		enhancer.setCallback(this);//设置回调方法
		return enhancer.create();//创建代理对象
	}

	public Object intercept(Object proxy, Method method, Object[] args,
			MethodProxy  methodProxy) throws Throwable {
		PersonServiceBean bean = (PersonServiceBean) this.targetObject;
		Object result = null;
		if(bean.getUser()!=null){
			result = methodProxy.invoke(targetObject, args);
		}
		return result;
	}
}
 

 

package junit.test16;

import static org.junit.Assert.*;

import org.junit.Test;


import cn.zyj16.service.PersonService;
import cn.zyj16.service.impl.PersonServiceBean;
import cn.zyj16.aop.CGlibProxyFactory;

public class AOPTest {

	@Test public void cglibTest2(){
		CGlibProxyFactory factory = new CGlibProxyFactory();
		//此事创建的代理对象是PersonServiceBean的子类!
		PersonServiceBean service = (PersonServiceBean) factory.createProxyIntance(new PersonServiceBean("xxx"));
		service.save("999");
	}
}
 

 

 

AOP中的概念

Aspect(切面):指横切性关注点的抽象即为切面,它与类相似,只是两者的关注点不一样,类是对物体特征的抽象,而切面横切性关注点的抽象.

joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点,实际上joinpoint还可以是field或类构造器)

Pointcut(切入点):所谓切入点是指我们要对那些joinpoint进行拦截的定义.

Advice(通知):所谓通知是指拦截到joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知

Target(目标对象):代理的目标对象

Weave(织入):指将aspects应用到target对象并导致proxy对象创建的过程称为织入.

Introduction(引入):在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.

 

 

使用Spring进行面向切面(AOP)编程

要进行AOP编程,首先我们要在spring的配置文件中引入aop命名空间:

<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"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

           http://www.springframework.org/schema/aop                                  http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

</beans>

 

Spring提供了两种切面声明方式,实际工作中我们可以选用其中一种:

基于XML配置方式声明切面。

基于注解方式声明切面。


基于注解方式声明切面

首先启动对@AspectJ注解的支持(蓝色部分)

 

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns:context="http://www.springframework.org/schema/context" 

       xmlns:aop="http://www.springframework.org/schema/aop"      

       xsi:schemaLocation="http://www.springframework.org/schema/beans

           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd

           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

        <aop:aspectj-autoproxy/> 

        <bean id="myInterceptor" class="cn.zyj17.service.MyInterceptor"/>

        <bean id="personService" class="cn.zyj17.service.impl.PersonServiceBean"></bean>

</beans>

 

 

 

 

package cn.zyj17.service;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
/**
 * 切面
 *
 */
@Aspect
public class MyInterceptor {
	@Pointcut("execution (* cn.zyj17.service.impl.PersonServiceBean.*(..))")
	private void anyMethod() {}//声明一个切入点
	
	@Before("anyMethod() && args(name)")
	public void doAccessCheck(String name) {
		System.out.println("前置通知:"+ name);
	}
	@AfterReturning(pointcut="anyMethod()",returning="result")
	public void doAfterReturning(String result) {
		System.out.println("后置通知:"+ result);
	}
	@After("anyMethod()")
	public void doAfter() {
		System.out.println("最终通知");
	}
	@AfterThrowing(pointcut="anyMethod()",throwing="e")
	public void doAfterThrowing(Exception e) {
		System.out.println("例外通知:"+ e);
	}
	
	@Around("anyMethod()")
	public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
		//if(){//判断用户是否在权限
		System.out.println("进入方法");
		Object result = pjp.proceed();
		System.out.println("退出方法");
		//}
		return result;
	}
	
}

 

 

 

package junit.test17;

import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.zyj17.service.PersonService;

public class SpringAOPTest {

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
	}

	@Test public void interceptorTest(){
		ApplicationContext cxt = new ClassPathXmlApplicationContext("beans.xml");
		PersonService personService = (PersonService)cxt.getBean("personService");//接口
		personService.save("xx");
	}
}
 

 

基于基于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"
       xmlns:context="http://www.springframework.org/schema/context" 
       xmlns:aop="http://www.springframework.org/schema/aop"      
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
       <aop:aspectj-autoproxy/> 
        <bean id="personService" class="cn.zyj19.service.impl.PersonServiceBean"></bean>
        <bean id="aspetbean" class="cn.zyj19.service.MyInterceptor"/>
        <aop:config>
        	<aop:aspect id="asp" ref="aspetbean">
        		<aop:pointcut id="mycut" expression=" execution(* cn.zyj19.service..*.*(..))"/>
        		<aop:before pointcut-ref="mycut" method="doAccessCheck"/>
        		<aop:after-returning pointcut-ref="mycut" method="doAfterReturning"/>
			  	<aop:after-throwing pointcut-ref="mycut" method="doAfterThrowing"/>
			  	<aop:after pointcut-ref="mycut" method="doAfter"/>
			  	<aop:around pointcut-ref="mycut" method="doBasicProfiling"/>
        	</aop:aspect>
        </aop:config>
</beans>

 package cn.zyj19.service;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
/**
 * 切面
 *
 */
public class MyInterceptor {
	public void doAccessCheck() {
		System.out.println("前置通知");
	}

	public void doAfterReturning() {
		System.out.println("后置通知");
	}
	
	public void doAfter() {
		System.out.println("最终通知");
	}
	
	public void doAfterThrowing() {
		System.out.println("例外通知");
	}
	
	public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
		System.out.println("进入方法");
		Object result = pjp.proceed();
		System.out.println("退出方法");
		return result;
	}
}
 

 

package junit.test19;

import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.zyj19.service.PersonService;

public class SpringAOPTest {

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
	}

	@Test public void interceptorTest(){
		ApplicationContext cxt = new ClassPathXmlApplicationContext("beans.xml");
		PersonService personService = (PersonService)cxt.getBean("personService");
		personService.save("xx");
	}
}
 

 

 

 

 

 

 

 

 

 

 

分享到:
评论

相关推荐

    spring aop简单例子

    总结一下,Spring AOP提供了一种优雅的方式来处理横切关注点,使得我们可以专注于业务逻辑而不必关心这些关注点的实现。通过切面、连接点、通知等概念,我们可以轻松地插入日志、事务管理等行为。这个简单的例子展示...

    Spring AOP面向方面编程原理:AOP概念

    接下来,我们通过一个简单的Spring AOP示例来加深对上述概念的理解。假设我们需要在调用某个公共方法前记录日志,我们可以定义一个`BeforeAdvice`,并在目标方法上应用此通知。 ```java package com.example.aop; ...

    Spring AOP的简单实现

    总结,Spring AOP通过切面、切入点和通知等概念,提供了在不入侵原有代码的基础上,进行日志记录、事务管理、性能监控等多种跨切面操作的能力。在实际开发中,利用AOP可以有效地提高代码的复用性和模块化程度,降低...

    spring aop简单应用示例

    总结来说,Spring AOP提供了一种优雅的方式来处理横切关注点,使得代码更加模块化,提高了可维护性和复用性。通过理解和应用这些概念,开发者可以更好地管理他们的应用程序,尤其是那些需要大量日志记录、事务管理或...

    spring aop demo 两种实现方式

    总结来说,Spring AOP提供了一种强大的方式来实现横切关注点,降低了代码的耦合度。无论是通过注解还是配置文件,都能够有效地实现切面的定义和拦截操作。理解并掌握Spring AOP的使用,对于提升Spring框架的应用能力...

    Spring AOP IOC源码笔记.pdf

    Spring框架是Java开发中不可...总结,Spring框架的IoC和AOP特性极大地简化了Java开发,通过依赖注入解耦了组件,通过面向切面编程解决了共性问题。理解并熟练掌握这些概念和机制,对于提升开发效率和代码质量至关重要。

    SpringAOP简单项目实现

    总结,这个"SpringAOP简单项目实现"涵盖了Spring AOP的基础知识,包括切面、通知、切入点的定义与配置,以及如何在实际项目中使用Maven进行构建和依赖管理。对于初学者来说,这是一个很好的实践案例,能够帮助他们...

    spring之AOP(动态代理)

    总结一下,Spring的AOP机制通过JDK动态代理和CGLIB动态代理提供了强大的横切关注点管理功能。开发者可以轻松地定义切面和通知,以实现如日志、事务管理等功能,同时保持核心业务代码的清晰和简洁。在Spring Boot项目...

    spring aop

    总结来说,这个项目提供了基于Maven和Spring的Web应用实例,展示了如何利用Spring AOP进行切面编程,包括XML配置和注解两种方式。通过学习这个项目,你可以深入理解Spring AOP的工作原理,以及如何在实际项目中有效...

    spring aop注解版

    总结起来,Spring AOP注解版通过简单易懂的注解,使得面向切面编程变得更加直观和方便。它降低了横切关注点与业务逻辑之间的耦合度,提高了代码的可维护性和复用性。通过合理利用这些注解,开发者可以轻松地实现日志...

    springAOP中文文档

    ### Spring AOP 概念与实践 #### 一、AOP 概述 **面向切面编程 (Aspect-Oriented Programming, AOP)** 是一种编程范式,它旨在提高程序的模块化程度,通过分离横切关注点来解决传统面向对象编程中难以处理的问题。...

    Spring3.0AOP所需jar包

    总结起来,Spring 3.0 AOP所需的jar包主要包括Spring AOP模块、AspectJ库以及Spring框架的核心组件。理解并正确配置这些依赖对于成功实现Spring AOP功能至关重要。在实际开发过程中,开发者还需要了解如何编写切面、...

    spring Aop文档

    下面是一个简单的基于注解的Spring AOP配置示例: ```java // 定义切面 @Aspect @Component public class LoggingAspect { // 前置通知 @Before("execution(* com.example.service.*.*(..))") public void log...

    Spring AOP切面编程简介

    总结起来,Spring AOP提供了一种声明式的方式来处理横切关注点,使得我们的代码更加整洁、可维护。通过使用切面,我们可以专注于业务逻辑,而将常见的非业务逻辑操作(如日志、事务等)封装到切面中,从而提高了代码...

    Spring AOP 的实现例子(基于XML配置实现)

    总结来说,Spring AOP的XML配置方式允许我们灵活地定义切面、通知和连接点,实现对程序的非侵入式增强。虽然现在更多地使用注解式配置,但理解XML配置方式对于全面掌握Spring AOP仍然至关重要。

    springAOP演示例子

    这个"springAOP演示例子"很可能会包含一个简单的Spring项目,展示如何创建和配置切面,定义切入点和通知,并观察其在实际代码中的工作原理。通过深入理解和实践这个例子,你可以更好地掌握Spring AOP的使用,提升你...

    Spring AOP 项目

    **Spring AOP 项目概述** Spring AOP(Aspect Oriented Programming,面向切面编程)是Spring框架中的一个重要组成部分,它提供了在Java应用中实现切面编程的能力。在传统的面向对象编程中,关注点分离(例如日志、...

    spring-aop.jar

    以下是一个简单的Spring AOP使用示例: ```java @Aspect public class LoggingAspect { @Before("execution(* com.example.service.*.*(..))") public void logBefore(JoinPoint joinPoint) { // 日志记录代码 ...

    javaXML方式实现SpringAop编程(源码+jar包)

    接下来,我们将使用XML配置来创建一个简单的Spring AOP示例: 1. **配置Spring容器**:首先,我们需要一个Spring配置文件(如`springstudy02/spring-context.xml`),在其中定义bean并启用AOP支持。例如: ```xml ...

Global site tag (gtag.js) - Google Analytics