`
donald3003a
  • 浏览: 65655 次
  • 性别: Icon_minigender_1
  • 来自: 成都
社区版块
存档分类
最新评论
  • 淼淼E馒头: 这举列有点不恰当啊。。电影人和不同类型的电影。是两个不同概念 ...
    合成模式

AOP的最简单的两种实现方式

阅读更多
这里介绍下aop最简单的两种实现方式。
1、动态代理
2、cglib
首先看动态代理。
动态代理大家都知道是必须基于接口的实现
1、接口
import com.xxx.aop.User;

public interface IUserbean {

	public void addUser(User user);

	public User getUser(int id);

}



2、要代理的类
import com.xxx.aop.User;

public class UserbeanImpl implements IUserbean {

	public void addUser(User user) {
		System.out.println("Add user");
	}

	public User getUser(int id) {
		User u = new User();
		u.setName("li1");
		return u;
	}

}




3、代理类

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import com.xxx.aop.User;

public class JDKProxy implements InvocationHandler {

	private Object target;

	public Object bind(Object target) {
		this.target = target;
		return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);

	}

	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		if (method.getName().equals("getUser")) {
			before((Integer) args[0]);
		} else {
			before(args);
		}
		Object result = null;
		result = method.invoke(target, args);
		if (method.getName().equals("getUser")) {
			afert((User) result);
		} else {
			afert(result);
		}

		return result;
	}

	private void afert(Object o) {
		System.out.println(o);
	}

	private void before(int id) {
		System.out.println(id);
	}

	private void before(Object[] args) {
		System.out.println(((User) args[0]).getName());
	}

	private void afert(User user) {
		System.out.println(user.getName());
	}

}

其中还添加了4个afert 与 before方法。Spring aop就是通过配置文件来完全实现的。下章我们也会通过配置文件来实现。
4、测试类
import com.xxx.aop.User;

public class TestProxy {

	public static void main(String[] args) {
		JDKProxy proxy = new JDKProxy();
		IUserbean userBean = (IUserbean) proxy.bind(new UserbeanImpl());
		User user = new User();
		user.setId(1);
		user.setName("li");
		userBean.addUser(user);
		userBean.getUser(1);
	}

}


5、User javebean类
public class User {

	private int id;

	private String name;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

}


cglib原理完全一样,只是实现的不一样

1、被代理的类
import com.xxx.aop.User;

public class UserBean {

	public UserBean() {
	}

	public void addUser(User user) {
		System.out.println("this is addUser() method!");
	}

	public void deleteUser() {
		System.out.println("this is deleteUser() method!");
	}

	public void getUser(User user) {
		throw new NullPointerException("It is null");
	}

	public void updateUser() {
		System.out.println("this is updateUser() method!");
	}

}


2、代理类
public class CGLibProxy implements MethodInterceptor {

	private Object targetObject;

	public Object createProxyObject(Object targetObject) {
		this.targetObject = targetObject;
		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(this.targetObject.getClass());
		enhancer.setCallback(this);
		return enhancer.create();
	}

	public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
		before(args);
		Object result = null;
		try {
			result = methodProxy.invoke(targetObject, args);
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
		afert(args);
		return result;
	}

	private void before(Object[] args) {
		System.out.println(((User) args[0]).getName());
	}

	private void afert(Object[] args) {
		System.out.println(((User) args[0]).getName());
	}
}


3、测试类
import com.xxx.aop.User;

public class TestProxy {

	public static void main(String[] args) {
		CGLibProxy cProxy = new CGLibProxy();
		UserBean userBean = (UserBean) cProxy.createProxyObject(new UserBean());
		User user = new User();
		user.setId(1);
		user.setName("li");
		userBean.addUser(user);
		userBean.getUser(user);
	}
}


通过以上就可以看出通过代理,我们可以获取被代理类的方法,类名,参数以及返回值。
分享到:
评论

相关推荐

    Spring实现AOP的4种方式

    每种实现方式都有其适用场景和优缺点。基于代理的方式简单易懂,但受限于目标对象是否需要实现接口;AspectJ注解方式简化了代码,提高了可读性;XML配置提供了清晰的结构,适合大型项目;Java配置则结合了灵活性和可...

    Spring AOP面向切面三种实现

    本文将详细解析Spring AOP的三种实现方式,帮助你深入理解这一重要概念。 首先,理解AOP的基本概念至关重要。AOP是一种编程范式,它允许开发者定义“切面”,即关注点的模块化,如日志、事务管理等。这些切面可以...

    Spring AOP的简单实现

    在Spring AOP中,切面可以通过两种方式定义:使用注解或者XML配置。在这个例子中,我们可能会选择注解方式,因为它更简洁且易于理解。 1. **创建切面类(Aspect)** 我们可以创建一个名为`LoggingAspect`的Java类...

    Xml配置实现AOP

    通过研究这些示例,你可以更好地理解和应用这两种AOP实现方式。 总结来说,XML配置在Spring AOP中扮演着核心角色,它允许我们精细控制切面的定义、通知的执行时机以及代理的生成方式。无论是基于代理还是自动代理,...

    一个简单的spring AOP的实现

    1. 注解驱动的AOP:这是最常用的实现方式,通过在方法上添加注解(如`@Before`, `@After`, `@Around`, `@AfterReturning`, `@AfterThrowing`)来定义通知,并使用`@Aspect`注解定义切面。 2. XML配置驱动的AOP:...

    Sping aop简单示例

    在这个"Spring AOP简单示例"中,我们将深入探讨这五个关键元素,并通过XML配置来实现它们。 首先,**切面(Aspect)**是关注点的模块化,这些关注点定义了跨越多个对象的行为或责任。在Spring AOP中,切面可以是...

    SpringBoot基于注解实现Aop

    在Spring Boot框架中,AOP(面向切面编程)是一种强大的设计模式,它允许程序员将关注点分离,比如日志、事务管理等,从核心业务逻辑中抽离出来。本指南将详细介绍如何通过注解来实现Spring Boot中的AOP。 首先,让...

    最简单的SpringAOP入门案例

    5. **代理模式**:Spring AOP通过代理模式实现切面功能,有JDK动态代理和CGLIB代理两种方式,前者针对实现了接口的类,后者则用于未实现接口的类。 通过这个简单的案例,你应该对Spring AOP有了初步的理解。随着...

    Java动态代理两种实现方式

    Java提供了两种主要的动态代理实现方式:JDK自身的动态代理(基于接口)和Cglib库。 ### JDK动态代理 JDK动态代理是通过`java.lang.reflect.Proxy`类和`java.lang.reflect.InvocationHandler`接口来实现的。Proxy类...

    spring aop xml实现

    5. **织入切面**:Spring默认使用代理模式进行织入,有两种类型的代理:JDK动态代理和CGLIB代理。JDK代理适用于实现了接口的类,而CGLIB代理用于未实现接口的类。可以全局设置代理类型,也可以针对每个bean设置: `...

    AOP的实现机制.pdf

    - **字节码操作**:更底层的实现方式,如AspectJ和ASM库,它们在类加载到JVM之前修改字节码,直接在运行时织入切面。这种方式提供了更大的灵活性,可以处理无法通过代理模式解决的场景,例如静态方法或构造函数。 ...

    最简单的aop切面方法

    在这个主题中,我们将深入探讨"最简单的aop切面方法"。 首先,让我们了解AOP的基本概念。AOP的核心是切面(Aspect),它封装了跨越多个对象的行为或责任。在Spring框架中,切面可以通过编写Aspect类来实现。切面...

    Spring通过注解实现AOP

    在Spring中,AOP主要通过两种方式实现:一种是基于XML配置,另一种是基于注解。这里我们重点讲解基于注解的方式。Spring支持的注解包括`@Aspect`、`@Before`、`@After`、`@Around`、`@Pointcut`等。 1. **@Aspect**...

    spring之AOP(动态代理)

    在Spring中,AOP主要通过两种动态代理技术实现:JDK动态代理和CGLIB动态代理。 首先,让我们详细了解一下JDK动态代理。JDK动态代理基于Java的接口实现,它适用于目标对象实现了至少一个接口的情况。在运行时,JDK...

    Java中AOP编程实现.rar

    有JDK动态代理和CGLIB代理两种方式,前者基于接口,后者基于类。如果目标对象实现了接口,Spring将使用JDK动态代理;否则,它会使用CGLIB代理。 8. **@Aspect注解**:在Java类上使用`@Aspect`注解,声明该类为一个...

    Spring-Aop源码实现

    ZooKeeper提供了一种简单的方式,帮助开发者避免编写复杂的协调代码。 ### 总结 Hadoop作为一个强大的大数据处理平台,其核心组件HDFS和MapReduce奠定了其在大数据领域的地位。此外,Hadoop的生态系统还包含了众多...

    简易的AOP框架

    通过这样的简易AOP框架,开发者可以学习到AOP的基本思想和实现方式,了解如何在不修改原始代码的情况下,添加跨切面的关注点,提高代码的可维护性和复用性。同时,这也是一种实践面向切面编程理念的有益尝试,有助于...

    Spring基础:Spring AOP简单使用

    在Spring中,AOP通过代理模式实现,可以分为JDK动态代理和CGLIB代理两种方式。 1. **AOP概念** - **切面(Aspect)**:切面是关注点的模块化,比如日志、安全检查等,它将分散在代码各处的相同关注点集中在一起。 ...

    springAOP中文文档

    它提供了一种声明式的 AOP 实现方式,允许开发者使用注解或 XML 配置来定义切面、通知和切点。 在 Spring 中使用 AspectJ 需要进行以下配置: 1. **启用 AspectJ 注解支持**:为了在 Spring 应用中使用 AspectJ ...

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

    本笔记主要聚焦于Spring框架中的重要概念——面向切面编程(AOP),并对比讲解了两种实现方式:注解(Annotation)实现和XML配置实现。AOP允许我们在程序执行过程中插入自定义的行为,如日志记录、事务管理等,使得...

Global site tag (gtag.js) - Google Analytics