这里我们学习一下代理模式，JDK的动态代理，以及以JDK为基础的springAOP实现
代理模式：类结构的模式，优点就是不需要更改原有类（被代理类）就能增强原有类（被代理类）的功能，缺点就是必须实现原有类（被代理类）的接口
JDK的动态代理：优点就是不必“复制”原有类（被代理类）接口实现类，缺点就是必须为每个被代理类实现几乎一样的方法
springAOP：优点就是采用springIOC，JDK动态代理等技术来实现AOP机制
我们展示一个类的几个方法，分别采用代理模式，JDK动态代理，springAOP机制来做些额外功能
这里定义一个接口，一个实现类
package com.fruitking.proxy;
/**
* 汽车服务类接口
* @author fruitking
* @since 2010-02-23
*/
public interface CarService {
/**
* 启动汽车
*/
public void start();
/**
* 获得汽车搭载人数
* @return
*/
public int getLoadAmount();
/**
* 设置驾驶员
* @param driver
* @return
*/
public String setDriver(String driver);
/**
* 搭载货物
* @param goods
* @throws NullPointerException
* @throws IllegalArgumentException
*/
public void loadGoods(String goods)throws NullPointerException,IllegalArgumentException;
}
package com.fruitking.proxy;
/**
* 汽车服务类接口实现
* @author fruitking
* @since 2010-02-23
*/
public class CarServiceImpl implements CarService{
/**
* 启动汽车
*/
public void start(){
System.out.println("start my car...");
}
/**
* 获得汽车搭载人数
* @return
*/
public int getLoadAmount(){
System.out.println("count the person amount in my car...");
return 5;
}
/**
* 设置驾驶员
* @param driver
* @return
*/
public String setDriver(String driver){
System.out.println("driver is:"+driver);
if(driver==null||"".equals(driver)){
return "There is not driver.";
}else{
return "The driver's name is " + driver + ".";
}
}
/**
* 搭载货物
* @param goods
* @throws NullPointerException
* @throws IllegalArgumentException
*/
public void loadGoods(String goods)throws NullPointerException,IllegalArgumentException{
if(goods==null||"".equals(goods)){
throw new NullPointerException("The argument goods is null.");
}else if("tiger".equals(goods)){
throw new IllegalArgumentException("The argument goods is invalid.");
}
System.out.println("load goods is:"+goods);
}
}
先来看看代理模式，定义一个代理类，然后调用代理类
package com.fruitking.proxy.pattern;
import com.fruitking.proxy.CarService;
/**
* 汽车服务类接口的代理类实现
* @author fruitking
* @since 2010-02-23
*/
public class CarServiceProxy implements CarService {
private CarService carServiceTarget;//被代理的目标类
/**
* 在构造函数中设置被代理的目标类
* 也可以使用set方法设置被代理的目标类
* @param carServiceTarget
*/
public CarServiceProxy(CarService carServiceTarget){
this.carServiceTarget = carServiceTarget;
}
/**
* 启动汽车
*/
public void start(){
System.out.println("before excute target object...");
carServiceTarget.start();
System.out.println("after excute target object...");
}
/**
* 获得汽车搭载人数
* @return
*/
public int getLoadAmount(){
System.out.println("before excute target object...");
int amount = carServiceTarget.getLoadAmount();
System.out.println("after excute target object...");
return amount;
}
/**
* 设置驾驶员
* @param driver
* @return
*/
public String setDriver(String driver){
System.out.println("before excute target object...");
String resultObject = carServiceTarget.setDriver(driver);
System.out.println("after excute target object...");
return resultObject;
}
/**
* 搭载货物
* @param goods
* @throws NullPointerException
* @throws IllegalArgumentException
*/
public void loadGoods(String goods)throws NullPointerException,IllegalArgumentException{
//这里不实现任何操作
}
}
package com.fruitking.proxy.pattern;
import com.fruitking.proxy.CarService;
import com.fruitking.proxy.CarServiceImpl;
public class TestProxyPattern {
/**
* 代理模式中的调用
* @param args
*/
public static void main(String[] args) {
CarService carServiceTarget = new CarServiceImpl();
CarServiceProxy carServiceProxy = new CarServiceProxy(carServiceTarget);
//执行代理类的方法
//作用一：间接执行被代理类的方法，
//作用二：代理类可以在被代理类方法执行前后做一些额外操作
//总结：不更改原有类的功能和程序代码情况下，实现额外的功能能
//缺点：要为每个被代理类编写一个代理类，且需要实现相同接口的所有方法
carServiceProxy.start();
carServiceProxy.getLoadAmount();
String driver = carServiceProxy.setDriver("fruitking");
System.out.println(driver);
}
}
再来看看JDK动态代理
package com.fruitking.proxy.jdkdproxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import com.fruitking.proxy.CarService;
/**
* java动态代理实现类
* @author fruitking
* @since 2010-02-23
*/
public class CarServiceJDKDynamicProxy implements InvocationHandler {
private CarService carServiceTarget;//被代理的目标类
/**
* 在构造函数中设置被代理的目标类
* 也可以使用set方法设置被代理的目标类
* @param carServiceTarget
*/
public CarServiceJDKDynamicProxy(CarService carServiceTarget){
this.carServiceTarget = carServiceTarget;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("before excute target object...");
Object object = method.invoke(this.carServiceTarget,args);
System.out.println("after excute target object...");
return object;
}
}
package com.fruitking.proxy.jdkdproxy;
import java.lang.reflect.Proxy;
import com.fruitking.proxy.CarService;
import com.fruitking.proxy.CarServiceImpl;
public class TestJDKDynamicProxy {
/**
* JDK中动态代理技术中的代理调用
* @param args
*/
public static void main(String[] args) {
CarService carServiceTarget = new CarServiceImpl();
CarServiceJDKDynamicProxy carServiceJDKDynamicProxyTarget = new CarServiceJDKDynamicProxy(carServiceTarget);
CarService carServiceProxy = (CarService)Proxy.newProxyInstance(carServiceTarget.getClass().getClassLoader(),new Class[]{CarService.class}, carServiceJDKDynamicProxyTarget);
//执行代理类的方法
//作用一：间接执行被代理类的方法，
//作用二：代理类可以在被代理类方法执行前后做一些额外操作
//总结：不更改原有类的功能和程序代码情况下，实现额外的功能能
//缺点：要为每个被代理类编写一个代理类，且具有相同的接口
carServiceProxy.start();
carServiceProxy.getLoadAmount();
String driver = carServiceProxy.setDriver("fruitking");
System.out.println(driver);
}
}
最后来看看spring的AOP机制的实现
package com.fruitking.proxy.springaop;
import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;
/**
* 使用spring的AOP机制的事前通知接口实现
* @author fruitking
* @since 2010-02-23
*/
public class CarServiceBeforeAdvice implements MethodBeforeAdvice{
public void before(Method method, Object[] args, Object target)throws Throwable {
System.out.println("before excute target object...");
String methodName = method.getName(); //得到方法名
String targetClassName = target.getClass().getName();//得到调用类名
System.out.println(targetClassName+"."+methodName+"()");
}
}
package com.fruitking.proxy.springaop;
import java.lang.reflect.Method;
import org.springframework.aop.AfterReturningAdvice;
/**
* 使用spring的AOP机制的事前通知接口实现
* @author fruitking
* @since 2010-02-23
*/
public class CarServiceAfterAdvice implements AfterReturningAdvice {
public void afterReturning(Object returnValue,Method method,Object[] args,Object target)throws Throwable{
String methodName = method.getName(); //得到方法名
String targetClassName = target.getClass().getName();//得到调用类名
System.out.println(targetClassName+"."+methodName+"()");
System.out.println("after excute target object...");
}
}
package com.fruitking.proxy.springaop;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
/**
* 使用spring的AOP机制的事前通知接口实现
* @author fruitking
* @since 2010-02-23
*/
public class CarServiceAroundAdvice implements MethodInterceptor {
public Object invoke(MethodInvocation invocation) throws Throwable {
System.out.println("before around excute target object...");
String methodName = invocation.getMethod().getName(); //得到方法名
String targetClassName = invocation.getClass().getName();//得到调用类名
System.out.println(targetClassName+"."+methodName+"()");
Object result = invocation.proceed(); //调用横切点，即真实操作
System.out.println("after around excute target object...");
return result;
}
}
package com.fruitking.proxy.springaop;
import org.springframework.aop.ThrowsAdvice;
/**
* 使用spring的AOP机制的事前通知接口实现
* @author fruitking
* @since 2010-02-23
*/
public class CarServiceThrowsAdvice implements ThrowsAdvice {
public void afterThrowing(NullPointerException e){//可以定义多个方法，只要传入的参数是不同异常
System.out.print("not load anything goods!");
}
public void afterThrowing(IllegalArgumentException e){//可以定义多个方法，只要传入的参数是不同异常
System.out.print("load a tiger,it's very much dangerous!");
}
}
spring的配置文件，把这些使用IOC处理
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
<beans>
<bean id="carServiceTarget" class="com.fruitking.proxy.CarServiceImpl"/>
<bean id="carServiceBeforeAdvice" class="com.fruitking.proxy.springaop.CarServiceBeforeAdvice"/>
<bean id="carServiceAfterAdvice" class="com.fruitking.proxy.springaop.CarServiceAfterAdvice"/>
<bean id="carServiceAroundAdvice" class="com.fruitking.proxy.springaop.CarServiceAroundAdvice"/>
<bean id="carServiceThrowsAdvice" class="com.fruitking.proxy.springaop.CarServiceThrowsAdvice"/>
<bean id="carService" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces" value="com.fruitking.proxy.CarService"/>
<property name="target" ref="carServiceTarget"/>
<property name="interceptorNames">
<list>
<value>carServiceBeforeAdvice</value>
<value>carServiceAfterAdvice</value>
<value>carServiceAroundAdvice</value>
<value>carServiceThrowsAdvice</value>
</list>
</property>
</bean>
</beans>
package com.fruitking.proxy.springaop;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.fruitking.proxy.CarService;
public class TestSpringAOP {
/**
* 利用spring的AOP机制实现“代理”的横向抽取机制方式
* @param args
*/
public static void main(String[] args) {
ApplicationContext ctx=new ClassPathXmlApplicationContext("beans.xml");
CarService carService = (CarService) ctx.getBean("carService");
carService.start();
carService.getLoadAmount();
String driver = carService.setDriver("fruitking");
System.out.println(driver);
System.out.println("------------------------------");
carService.loadGoods("Miss Mary");
System.out.println("------------------------------");
try{
carService.loadGoods(null);
}catch(NullPointerException e){
e.printStackTrace();
}
System.out.println("------------------------------");
try{
carService.loadGoods("tiger");
}catch(IllegalArgumentException e){
e.printStackTrace();
}
}
}
分享到：
相关推荐
Jdk动态代理，基于接口的代理示例 InovactionHandler Proxy
spring之AOP（动态代理），包括jdk动态代理和CGLib动态代理
AOP的意思就是面向切面编程。本文主要是通过梳理JDK中自带的反射机制，实现 AOP动态代理模式，这也是Spring AOP 的实现原理
NULL 博文链接：https://hyp1987.iteye.com/blog/1833776
主要对Spring AOP的相关概念和简单的静态代理、动态代理以及常见的几种AOP配置方式做总结学习。主要包括：1. AOP的常见概念 2. 静态代理 3. jdk动态代理 4. Aspectj and Aspectjweaver 5. **aop-config** 6. CGLIB ...
Spring AOP 使用的动态代理主要有两种方式：JDK 动态代理和 CGLIB 代理。 JDK 动态代理：用于代理实现了接口的类。Spring 会使用 java.lang.reflect.Proxy 类来创建代理对象。 CGLIB 代理：用于代理没有实现接口的...
Spring-AOP-利用java中的动态代理和Spring的拦截器做到AOP
JDK动态代理,关于jdk动态代理的问题！详细的说明！JDK动态代理JDK动态代理
spring aop jdk 动态代理的底层实现解析模拟
动态代理是使用jdk的反射机制，创建对象的能力， 创建的是代理类的对象。 而不用你创建类文件。不用写java文件。 动态：在程序执行时，调用jdk提供的方法才能创建代理类的对象。jdk动态代理，必须有接口，目标类必须...
NULL 博文链接：https://johnyi.iteye.com/blog/385443
Spring框架的AOP中重要的一个知识点，动态代理，springAOP框架会根绝实际情况选择使用jdk的动态代理还是cglib的动态代理
Spring Aop的底层实现技术 --- Jdk动态代理原理 很不错的一篇文章
AOP之JDK动态代理和CGLib动态代理 ,具体效果和过程看博文 http://blog.csdn.net/evankaka/article/details/45195383
我们还提供了实际示例，演示如何在Spring AOP中使用JDK动态代理。 CGLib动态代理： 我们将深入研究CGLib动态代理，它允许您在不需要接口的情况下创建代理对象。您将了解CGLib的工作原理，以及如何生成子类来实现...
如果一个类实现了一个或多个接口，那么Spring就会使用默认的JDK动态代理，如果没有实现任何接口，就会使用cglib来代理。当然我们也可以手动改变这些设置。这也是比较容易掉坑的部分，如果设置错了代理方式，那么在...
为了说明Spring的AOP原理，本人使用代理模式中的动态代理完成演示AOP编程的原理的演示。相信，如果你耐心看完整个程序(几乎一行注释一行代码)，那么你对Spring这个东西就不是觉得有什么神秘了！ 阅读对象：凡是喜爱...
NULL 博文链接：https://jummy.iteye.com/blog/253406
基于JDK的动态代理。必须是面向接口的，只有实现了具体接口的类才能生成代理对象