`

十 使用JDK中的Proxy技术实现AOP功能

 
阅读更多
十 使用JDK中的Proxy技术实现AOP功能

通过代理对象来调用对象的方法,从而做出权限控制。

目标对象必须实现接口才能使用proxy技术创建代理对象。

PersonService.java

view plaincopy to clipboardprint?
01.package cn.pf.aop.service;   
02.  
03.public interface PersonService {   
04.    public void save(String name);   
05.    public void update(String name, Integer personId);   
06.    public String getName(Integer personId);   
07.}  
package cn.pf.aop.service;

public interface PersonService {
	public void save(String name);
	public void update(String name, Integer personId);
	public String getName(Integer personId);
}
 

PersonServiceBean.java

view plaincopy to clipboardprint?
01.package cn.pf.aop.service.impl;   
02.  
03.import cn.pf.aop.service.PersonService;   
04.  
05.public class PersonServiceBean implements PersonService {   
06.    private String user = null;   
07.       
08.    public PersonServiceBean() {   
09.  
10.    }   
11.  
12.    public PersonServiceBean(String user) {   
13.        this.setUser(user);   
14.    }   
15.  
16.    @Override  
17.    public String getName(Integer personId) {   
18.        System.out.println(this.getClass().getName()+" getName方法");   
19.        return "pf";   
20.    }   
21.  
22.    @Override  
23.    public void save(String name) {   
24.        System.out.println(this.getClass().getName()+" save方法");   
25.    }   
26.  
27.    @Override  
28.    public void update(String name, Integer personId) {   
29.        System.out.println(this.getClass().getName()+" update方法");   
30.    }   
31.  
32.    public void setUser(String user) {   
33.        this.user = user;   
34.    }   
35.  
36.    public String getUser() {   
37.        return user;   
38.    }   
39.  
40.}  
package cn.pf.aop.service.impl;

import cn.pf.aop.service.PersonService;

public class PersonServiceBean implements PersonService {
	private String user = null;
	
	public PersonServiceBean() {

	}

	public PersonServiceBean(String user) {
		this.setUser(user);
	}

	@Override
	public String getName(Integer personId) {
		System.out.println(this.getClass().getName()+" getName方法");
		return "pf";
	}

	@Override
	public void save(String name) {
		System.out.println(this.getClass().getName()+" save方法");
	}

	@Override
	public void update(String name, Integer personId) {
		System.out.println(this.getClass().getName()+" update方法");
	}

	public void setUser(String user) {
		this.user = user;
	}

	public String getUser() {
		return user;
	}

}
 

JDKProxyFactory.java

view plaincopy to clipboardprint?
01.package cn.pf.aop;   
02.  
03.import java.lang.reflect.InvocationHandler;   
04.import java.lang.reflect.Method;   
05.import java.lang.reflect.Proxy;   
06.  
07.import cn.pf.aop.service.impl.PersonServiceBean;   
08.  
09.public class JDKProxyFactory implements InvocationHandler {   
10.    private Object targetObject;   
11.       
12.    public Object createProxyIntance(Object targetObject){   
13.        this.targetObject = targetObject;   
14.        return Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(),    
15.                this.targetObject.getClass().getInterfaces(), this);   
16.    }   
17.  
18.    @Override  
19.    public Object invoke(Object proxy, Method method, Object[] arg2)   
20.            throws Throwable {   
21.        PersonServiceBean personServiceBean = (PersonServiceBean)targetObject;   
22.        Object result = null;   
23.        if(personServiceBean.getUser() != null){   
24.            result = method.invoke(targetObject, arg2);   
25.        }   
26.        return null;   
27.    }   
28.}  
package cn.pf.aop;

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

import cn.pf.aop.service.impl.PersonServiceBean;

public class JDKProxyFactory implements InvocationHandler {
	private Object targetObject;
	
	public Object createProxyIntance(Object targetObject){
		this.targetObject = targetObject;
		return Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(), 
				this.targetObject.getClass().getInterfaces(), this);
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] arg2)
			throws Throwable {
		PersonServiceBean personServiceBean = (PersonServiceBean)targetObject;
		Object result = null;
		if(personServiceBean.getUser() != null){
			result = method.invoke(targetObject, arg2);
		}
		return null;
	}
}
 

AOPTest.java

view plaincopy to clipboardprint?
01.package junit.test;   
02.  
03.import org.junit.Test;   
04.  
05.import cn.pf.aop.JDKProxyFactory;   
06.import cn.pf.aop.service.PersonService;   
07.import cn.pf.aop.service.impl.PersonServiceBean;   
08.  
09.  
10.public class AOPTest {   
11.    @Test public void proxyTest(){   
12.        JDKProxyFactory factory = new JDKProxyFactory();   
13.        PersonService personService = (PersonService) factory.createProxyIntance(new PersonServiceBean());   
14.        personService.save("111");   
15.    }   
16.}  
package junit.test;

import org.junit.Test;

import cn.pf.aop.JDKProxyFactory;
import cn.pf.aop.service.PersonService;
import cn.pf.aop.service.impl.PersonServiceBean;


public class AOPTest {
	@Test public void proxyTest(){
		JDKProxyFactory factory = new JDKProxyFactory();
		PersonService personService = (PersonService) factory.createProxyIntance(new PersonServiceBean());
		personService.save("111");
	}
}
 

Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(), this.targetObject.getClass().getInterfaces(), this);

创建代理对象的时候,加入了该目标对象所有的接口,即对所有的方法进行监听,任何一个方法的调用都会触发代理对象的invoke方法。this表示触发哪个代理对象的invoke方法,这里我们设置当前代理对象。

调用personService的save方法的时候,可以理解为,save方法被监听,进入代理对象的invoke方法,如果user!=null,则invoke方法中调用了personService的save方法,如果user==null,则什么也不做。

通过反射技术调用方法其实可以简单的理解为

xxx.invoke(obj,args)返回的结果是obj.xxx(args) 

end 完毕!

 

分享到:
评论

相关推荐

    使用JDK中的Proxy技术实现AOP功能与使用CGLIB实现AOP功能

    在Spring AOP中,如果目标对象实现了至少一个接口,那么Spring会选择使用JDK Proxy。以下是一个简单的示例: ```java public interface MyService { void doSomething(); } public class MyServiceImpl ...

    AOP__使用JDK中的Proxy技术实现AOP功能

    在Java中,我们可以使用JDK的动态代理(Proxy)来实现AOP的功能,这主要涉及到反射和接口编程。 **JDK动态代理的工作原理** JDK的Proxy类提供了一种机制,可以创建一个代理对象,该对象在调用方法时会执行自定义的...

    AOP_1.入门及使用JDK中的Proxy技术实现实例

    在Java领域,我们可以使用Spring框架提供的AOP支持,但本实例主要讨论的是如何使用JDK自身的动态代理(Proxy)技术来实现AOP。 JDK的Proxy类提供了创建动态代理对象的能力,这个代理对象可以代表一个或多个实现了...

    Aop jdk proxy实现小例子

    下面我们将详细讲解如何使用JDK Proxy实现Aop。 首先,我们需要定义一个接口,这个接口将代表我们要进行代理的目标对象的行为。例如,我们可以创建一个名为`Service`的接口: ```java public interface Service { ...

    Spring Aop的底层实现技术 --- Jdk动态代理原理

    Spring AOP 的底层实现技术 --- Jdk 动态代理原理 JDK 动态代理是 Spring AOP 的底层实现技术,允许开发者在运行期创建接口的代理实例。在 JDK 1.3 以后,JDK 动态代理技术提供了实现 AOP 的绝好底层技术。JDK 动态...

    Java JDK 实现AOP

    AOP的实现技术主要包括两大类: 1. **动态代理**:通过截取方法调用的方式,在不修改原有对象行为的基础上添加额外的功能。这种方式适用于运行时动态地改变行为。 2. **静态织入**:通过引入特定的语法创建“方面”...

    模拟spring aop【一】基于jdk动态代理实现的aop

    4. **Spring AOP中的JDK代理** - Spring AOP提供了`DefaultAdvisorAutoProxyCreator`,它可以自动为匹配的Bean创建JDK代理。 - 切面(Aspect)是Spring AOP的核心,它封装了通知(Advice),通知定义了切面的逻辑...

    JDK动态代理 spring aop 的原理

    在Java编程领域,JDK动态代理是实现动态创建代理对象的一种技术,它是Java标准库提供的一种强大工具。Spring AOP(面向切面编程)则是一种流行的应用框架,它利用动态代理来实现对业务代码的切面增强,如日志、事务...

    从JDK动态代理到spring AOP

    本篇将详细探讨JDK动态代理和Spring AOP,以及它们在实际应用中的作用。 首先,JDK动态代理是Java提供的一种在运行时创建代理对象的技术。它允许我们在不修改原有类的基础上,为已有接口添加额外的功能。动态代理的...

    SpringIOC,DI+dynamic proxy 实现盗版AOP

    本文将深入探讨如何使用Spring的IOC和DI特性,结合动态代理(Dynamic Proxy)来实现一种类似AOP(面向切面编程)的功能,以达到在不修改原有代码的情况下增强或拦截方法调用的目的。 **一、Spring IOC(控制反转)*...

    JavaEE JDK动态代理实现AOP切面功能

    JavaEE JDK动态代理是Java平台中实现面向切面编程(AOP)的一种方式,它允许我们在不修改原有代码的情况下,为已有对象添加额外的功能。在Java中,动态代理主要通过`java.lang.reflect.Proxy`类和`java.lang.reflect...

    代理模式,JDK动态代理,SpringAOP来龙去脉

    - 展示Spring AOP的配置,定义切面、通知以及如何在业务代码中使用。 7. **优缺点**: - JDK动态代理简单易用,但仅适用于实现了接口的目标对象。 - Spring AOP更强大,支持多种代理方式和通知类型,但可能带来...

    使用代理实现简易的spring aop功能

    在Spring AOP中,有两种主要的代理方式:JDK动态代理和CGLIB代理。JDK动态代理基于接口实现,而CGLIB代理则是在运行时动态生成目标类的子类。 首先,我们需要理解Spring Bean工厂。Bean工厂是Spring容器的核心,...

    42 离开Spring AOP,我们如何实现AOP功能?慕课专栏1

    Spring AOP默认使用JDK动态代理来实现AOP功能。JDK动态代理基于Java反射API,它要求被代理的对象必须实现至少一个接口。如果目标类没有实现接口,或者希望进行更底层的代理(如方法拦截),Spring AOP会使用CGLIB库...

    Spring-AOP-JDK动态代理

    本篇将详细讲解Spring中的AOP实现,特别是JDK动态代理的应用。 首先,我们要了解什么是AOP(Aspect Oriented Programming,面向切面编程)。AOP是一种编程范式,旨在解决应用程序中分散的、横切关注点的问题,如...

    反射实现 AOP 动态代理模式(Spring AOP 的实现原理)

    在Spring AOP中,我们通常使用@Aspect注解来定义切面类。切面类中可以包含多个通知(Advice),包括前置通知(Before)、后置通知(After)、返回通知(After-returning)、异常通知(After-throwing)和环绕通知...

    实现AOP功能的jar包

    9. **代理(Proxy)**: 在Spring AOP中,为了实现切面功能,它创建了代理对象来包装原始的目标对象。有两种类型的代理:JDK动态代理和CGLIB代理。JDK代理用于实现了接口的目标对象,而CGLIB代理用于没有实现接口的类...

    spring_aop之JDK的动态代理

    在Spring AOP中,当目标对象实现了至少一个接口时,Spring会使用JDK的动态代理来创建代理对象。这是因为JDK的动态代理只适用于实现了接口的类,它通过生成一个与目标类接口相同的新类来实现代理。这个新类在运行时被...

    JDK-proxy-mode-spring-source-code-.zip_spring code

    在Spring AOP中,当启用JDK代理时,Spring会为我们的目标对象创建一个代理,这个代理对象实现了与目标对象相同的所有接口。当调用代理对象的方法时,实际上是调用了`InvocationHandler`的`invoke`方法,Spring会在...

    从JDK动态代理看Spring之AOP实现

    在Java开发中,AOP(面向切面编程)是一种重要的编程范式,它允许程序员将关注点分离,比如日志、事务管理等通用功能,从核心业务逻辑中解耦出来。Spring框架是Java世界里AOP应用的典型代表。本文将深入探讨Spring是...

Global site tag (gtag.js) - Google Analytics