java代理模式（JDK和cglib以及Spring AOP）

java动态代理（JDK和cglib）

JAVA的动态代理
代理模式
代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。
按照代理的创建时期，代理类可以分为两种。
静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。
动态代理：在程序运行时，运用反射机制动态创建而成。

首先看一下静态代理：
1、Count.java

Java代码

1. package net.battier.dao;
3. /**
4. * 定义一个账户接口
5. *
6. * @author Administrator
7. *
8. */
9. public interface Count {
10. // 查看账户方法
11. public void queryCount();
13. // 修改账户方法
14. public void updateCount();
16. }

2、CountImpl.java

Java代码

1. package net.battier.dao.impl;
3. import net.battier.dao.Count;
5. /**
6. * 委托类(包含业务逻辑)
7. *
8. * @author Administrator
9. *
10. */
11. public class CountImplimplements Count {
13. @Override
14. public void queryCount() {
15. System.out.println("查看账户方法...");
17. }
19. @Override
20. public void updateCount() {
21. System.out.println("修改账户方法...");
23. }
25. }
27. 、CountProxy.java
28. package net.battier.dao.impl;
30. import net.battier.dao.Count;
32. /**
33. * 这是一个代理类（增强CountImpl实现类）
34. *
35. * @author Administrator
36. *
37. */
38. public class CountProxyimplements Count {
39. private CountImpl countImpl;
41. /**
42. * 覆盖默认构造器
43. *
44. * @param countImpl
45. */
46. public CountProxy(CountImpl countImpl) {
47. this.countImpl = countImpl;
48. }
50. @Override
51. public void queryCount() {
52. System.out.println("事务处理之前");
53. // 调用委托类的方法;
54. countImpl.queryCount();
55. System.out.println("事务处理之后");
56. }
58. @Override
59. public void updateCount() {
60. System.out.println("事务处理之前");
61. // 调用委托类的方法;
62. countImpl.updateCount();
63. System.out.println("事务处理之后");
65. }
67. }

3、TestCount.java

Java代码

1. package net.battier.test;
3. import net.battier.dao.impl.CountImpl;
4. import net.battier.dao.impl.CountProxy;
6. /**
7. *测试Count类
8. *
9. * @author Administrator
10. *
11. */
12. public class TestCount {
13. public staticvoid main(String[] args) {
14. CountImpl countImpl = new CountImpl();
15. CountProxy countProxy = new CountProxy(countImpl);
16. countProxy.updateCount();
17. countProxy.queryCount();
19. }
20. }

观察代码可以发现每一个代理类只能为一个接口服务，这样一来程序开发中必然会产生过多的代理，而且，所有的代理操作除了调用的方法不一样之外，其他的操作都一样，则此时肯定是重复代码。解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能，那么此时就必须使用动态代理完成。
再来看一下动态代理：
JDK动态代理中包含一个类和一个接口：
InvocationHandler接口：
public interface InvocationHandler {
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable;
}
参数说明：
Object proxy：指被代理的对象。
Method method：要调用的方法
Object[] args：方法调用时所需要的参数

可以将InvocationHandler接口的子类想象成一个代理的最终操作类，替换掉ProxySubject。

Proxy类：
Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
参数说明：
ClassLoader loader：类加载器
Class<?>[] interfaces：得到全部的接口
InvocationHandler h：得到InvocationHandler接口的子类实例

Ps:类加载器
在Proxy类中的newProxyInstance（）方法中需要一个ClassLoader类的实例，ClassLoader实际上对应的是类加载器，在Java中主要有一下三种类加载器;
Booststrap ClassLoader：此加载器采用C++编写，一般开发中是看不到的；
Extendsion ClassLoader：用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类;
AppClassLoader：(默认)加载classpath指定的类，是最常使用的是一种加载器。

动态代理
与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。

动态代理示例:
1、BookFacade.java

Java代码

1. package net.battier.dao;
3. public interface BookFacade {
4. public void addBook();
5. }

2、BookFacadeImpl.java

Java代码

1. package net.battier.dao.impl;
3. import net.battier.dao.BookFacade;
5. public class BookFacadeImplimplements BookFacade {
7. @Override
8. public void addBook() {
9. System.out.println("增加图书方法。。。");
10. }
12. }
14. 、BookFacadeProxy.java
16. package net.battier.proxy;
18. import java.lang.reflect.InvocationHandler;
19. import java.lang.reflect.Method;
20. import java.lang.reflect.Proxy;
22. /**
23. * JDK动态代理代理类
24. *
25. * @author student
26. *
27. */
28. public class BookFacadeProxyimplements InvocationHandler {
29. private Object target;
30. /**
31. * 绑定委托对象并返回一个代理类
32. * @param target
33. * @return
34. */
35. public Object bind(Object target) {
36. this.target = target;
37. //取得代理对象
38. return Proxy.newProxyInstance(target.getClass().getClassLoader(),
39. target.getClass().getInterfaces(), this);//要绑定接口(这是一个缺陷，cglib弥补了这一缺陷)
40. }
42. @Override
43. /**
44. * 调用方法
45. */
46. public Object invoke(Object proxy, Method method, Object[] args)
47. throws Throwable {
48. Object result=null;
49. System.out.println("事物开始");
50. //执行方法
51. result=method.invoke(target, args);
52. System.out.println("事物结束");
53. return result;
54. }
56. }

3、TestProxy.java

Java代码

1. package net.battier.test;
3. import net.battier.dao.BookFacade;
4. import net.battier.dao.impl.BookFacadeImpl;
5. import net.battier.proxy.BookFacadeProxy;
7. public class TestProxy {
9. public staticvoid main(String[] args) {
10. BookFacadeProxy proxy = new BookFacadeProxy();
11. BookFacade bookProxy = (BookFacade) proxy.bind(new BookFacadeImpl());
12. bookProxy.addBook();
13. }
15. }

但是，JDK的动态代理依靠接口实现，如果有些类并没有实现接口，则不能使用JDK代理，这就要使用cglib动态代理了。

 

 

 

Cglib动态代理
JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。
示例
1、BookDAO.java

Java代码

1. package net.battier.dao;
3. public interfaceBookDAO{
4. public void addBook();
5. }

2、BookDAOImpl.java

Java代码

1. package net.battier.dao.impl;
3. /**
4. * 这个是没有实现接口的实现类
5. *
6. * @author student
7. *
8. */
9. public class BookDAOImpl implements BookDAO{
10. public void addBook() {
11. System.out.println("增加图书的普通方法...");
12. }
13. }

3、BookFacadeProxy.java

Java代码

1. package net.battier.proxy;
3. import java.lang.reflect.Method;
5. import net.sf.cglib.proxy.Enhancer;
6. import net.sf.cglib.proxy.MethodInterceptor;
7. import net.sf.cglib.proxy.MethodProxy;
9. /**
10. * 使用cglib动态代理 实现MethodInterceptor接口
11. *
12. * @author student
13. *
14. */
15. public class BookFacadeCglibimplements MethodInterceptor {
16. private Object target;
18. /**
19. * 创建代理对象
20. *
21. * @param target
22. * @return
23. */
24. public Object getInstance(Object target) {
25. this.target = target;
26. Enhancer enhancer = new Enhancer();
27. enhancer.setSuperclass(this.target.getClass());
28. // 回调方法
29. enhancer.setCallback(this);
30. // 创建代理对象
31. return enhancer.create();
32. }
34. @Override
35. // 回调方法
36. //调用此方法的类就是callback类，也就是代理类BookFacadeCglib自身，通过Enhancer的setCallback方法进行设置
37. public Object intercept(Object obj, Method method, Object[] args,
38. MethodProxy proxy) throws Throwable {
39. System.out.println("事物开始");
40. //调用super也就是被代理类的方法
41. proxy.invokeSuper(obj, args);
42. System.out.println("事物结束");
43. return null;
46. }
48. }

4、TestCglib.java

Java代码

1. package net.battier.test;
3. import net.battier.dao.impl.BookFacadeImpl1;
4. import net.battier.proxy.BookFacadeCglib;
6. public class TestCglib {
8. public staticvoid main(String[] args) {
9. BookFacadeCglib cglib=new BookFacadeCglib();
10. BookFacadeImpl1 bookCglib=(BookFacadeImpl1)cglib.getInstance(new BookFacadeImpl1());
11. bookCglib.addBook();
12. }
13. }

 

 

 

spring AOP

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。Spring主要通过代理来实现AOP。

切面(Aspect):对横切关注点的抽象(类似类对对象的抽象）
连接点(JoinPoint):被拦截到的点,泛指方法。
切入点(CutPoint):对哪些连接点进行拦截的定义。

通知(Advice):在特定的连接点，AOP框架执行的动作.前置/后置/例外/最终/环绕通知。
引入（Introduction）: 添加方法或字段到被通知的类。Spring允许引入新的接口到任何被通知的对象。
目标对象（Target Object）: 包含连接点的对象。也被称作被通知或被代理对象。
AOP代理（AOP Proxy）: AOP框架创建的对象，包含通知。在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。
织入（Weaving）: 组装切面来创建一个被通知对象。这可以在编译时完成也可以在运行时完成。Spring在运行时完成织入。

示例代码：

接口类：

Java代码

1. package org.iti.wxl.springaop;
3. public interface UserService {
4. public String getUser(String userId);
5. public void addUser();
6. }

package org.iti.wxl.springaop;

public interface UserService {
	public String getUser(String userId);
	public void addUser();
}

对接口的实现：

Java代码

1. package org.iti.wxl.springaop;
3. public class UserServiceImplimplements UserService {
4. @Override
5. public String getUser(String userId) {
6. System.out.println("this is getUser() method!");
7. return "user";
8. }
9. @Override
10. public void addUser() {
11. System.out.println("this is addUser() method!");
12. }
13. }

package org.iti.wxl.springaop;

public class UserServiceImpl implements UserService {
	@Override
	public String getUser(String userId) {
		System.out.println("this is getUser() method!");
		return "user";
	}
	@Override
	public void addUser() {
		System.out.println("this is addUser() method!");
	}
}

定义切面：

Java代码

1. package org.iti.wxl.springaop;
2. import org.aspectj.lang.ProceedingJoinPoint;
3. import org.aspectj.lang.annotation.After;
4. import org.aspectj.lang.annotation.AfterReturning;
5. import org.aspectj.lang.annotation.AfterThrowing;
6. import org.aspectj.lang.annotation.Around;
7. import org.aspectj.lang.annotation.Aspect;
8. import org.aspectj.lang.annotation.Before;
9. import org.aspectj.lang.annotation.Pointcut;
10. @Aspect
11. public class MyInterceptor {
12. @Pointcut("execution(* org.iti.wxl.springaop..*.*(..))")
13. private void pointCutmethod(){
14. }
15. @Before("pointCutmethod() && args(userId)")
16. public void doBefore(String userId){
17. System.out.println("前置通知 " + userId);
18. }
19. @AfterReturning("pointCutmethod()")
20. public void doAfterReturning(){
21. System.out.println("后置通知");
22. }
23. @AfterThrowing("pointCutmethod()")
24. public void doAfterException(){
25. System.out.println("异常通知");
26. }
27. @After("pointCutmethod()")
28. public void doAfter(){
29. System.out.println("最终通知");
30. }
31. @Around("pointCutmethod()")
32. public Object doAround(ProceedingJoinPoint pjp)throws Throwable{
33. System.out.println("环绕开始");
34. Object object = pjp.proceed();
35. System.out.println("环绕结束");
36. return object;
37. }
38. }

package org.iti.wxl.springaop;
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(* org.iti.wxl.springaop..*.*(..))")
	private void pointCutmethod(){
	}
	@Before("pointCutmethod() && args(userId)")
	public void doBefore(String userId){
		System.out.println("前置通知 " + userId);
	}
	@AfterReturning("pointCutmethod()")
	public void doAfterReturning(){
		System.out.println("后置通知");
	}
	@AfterThrowing("pointCutmethod()")
	public void doAfterException(){
		System.out.println("异常通知");
	}
	@After("pointCutmethod()")
	public void doAfter(){
		System.out.println("最终通知");
	}
	@Around("pointCutmethod()")
	public Object doAround(ProceedingJoinPoint pjp) throws Throwable{
		System.out.println("环绕开始");
		Object object = pjp.proceed();
		System.out.println("环绕结束");
		return object;
	}
}

说明：

第一个*表示方法的返回值,这里使用通配符,只有返回值符合条件的才拦截(!void表示有返回值)。
第一个..表示com.royzhou.aop包及其子包。
倒数第二个*表示包下的所有Java类都被拦截。
最后一个*表示类的所有方法都被拦截。
(..)表示方法的参数可以任意多个，如[(java.lang.String,java.lang.Integer)表示第一个参数是String,第二个参数是int的方法才会被拦截]

配置文件：

Java代码

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xmlns:context="http://www.springframework.org/schema/context"
5. xmlns:aop="http://www.springframework.org/schema/aop"
6. xsi:schemaLocation="http://www.springframework.org/schema/beans
7. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
8. http://www.springframework.org/schema/context
9. http://www.springframework.org/schema/context/spring-context-3.0.xsd
10. http://www.springframework.org/schema/aop
11. http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
12. <!-- 使用 annotation -->
13. <context:annotation-config />
14. <!-- 启用aop -->
15. <aop:aspectj-autoproxy proxy-target-class="true" />
16. <bean id="myInterceptor" class="org.iti.wxl.springaop.MyInterceptor"/>
17. <bean id="userService" class="org.iti.wxl.springaop.UserServiceImpl"/>
18. </beans>

<?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-3.0.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-3.0.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
	<!-- 使用 annotation -->
	<context:annotation-config />
	<!-- 启用aop -->
	<aop:aspectj-autoproxy proxy-target-class="true" />
	<bean id="myInterceptor" class="org.iti.wxl.springaop.MyInterceptor"/>
	<bean id="userService" class="org.iti.wxl.springaop.UserServiceImpl"/>
</beans>

测试类：

Java代码

1. package org.iti.wxl.springaop;
3. import org.springframework.context.ApplicationContext;
4. import org.springframework.context.support.ClassPathXmlApplicationContext;
6. public class SpringAOP {
8. public staticvoid main(String[] args) {
9. ApplicationContext cxt = new ClassPathXmlApplicationContext("bean.xml");
10. UserService userService = (UserService)cxt.getBean("userService");
11. userService.getUser("user1");
12. System.out.println("===========");
13. userService.addUser();
14. }
15. }

package org.iti.wxl.springaop;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringAOP {

	public static void main(String[] args) {
		ApplicationContext cxt = new ClassPathXmlApplicationContext("bean.xml");
		UserService userService = (UserService)cxt.getBean("userService");
		userService.getUser("user1");
		System.out.println("===========");
		userService.addUser();
	}
}

运行结果：

Java代码

1. 前置通知 user1
2. 环绕开始
3. this is getUser() method!
4. 后置通知
5. 最终通知
6. 环绕结束
7. ===========
8. 环绕开始
9. this is addUser() method!
10. 后置通知
11. 最终通知
12. 环绕结束

前置通知 user1
环绕开始
this is getUser() method!
后置通知
最终通知
环绕结束
===========
环绕开始
this is addUser() method!
后置通知
最终通知
环绕结束

在项目开发中，AOP主要用来配置spring的声明式事务管理，它还可用在日志管理，性能监测等。它为程序员编程提供了一种新思路，我们可以不断去发现它的新用途。