黑马程序员-Java代理

最新推荐文章于 2023-04-17 13:15:24 发布

shen111111

最新推荐文章于 2023-04-17 13:15:24 发布

阅读量424

点赞数

本文链接：https://blog.csdn.net/shen111111/article/details/25063919

版权

---------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

程序中的代理：

是为已经存在的多个具有相同接口的目标类的各个方法增加一些系统功能，比如，异常处理、日志、计算方法的运行时间、事件管理等。

原理：

编写一个与目标具有相同的接口的代理类，代理类中的每个方法，调用目标类的相同方法，并在调用的时候加上系统功能代码。

如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序代码，在配置文件中配置是使用目标类而不是使用代理类，这样以后很容易切换。

例如：想要日志功能就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时候后，想去掉系统功能也很容易。

交叉业务的编程问题：

即为面向方面的编程AOP

AOP：Aspect Orented Program

AOP的目标就是要是交叉业务模块化，可以采用切面代码移动到原始代码方法的周围，这与直接在方法中编写切面代码的运行效果是一样的。

动态代理技术：

JVM可以在运行期间动态的生成类的字节码文件，这种动态生产的类往往被用作代理类来使用，就是动态代理类。

JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。

CGLIB库可以动态的生成一个类或者子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么就可以使用CGLIB库。

代理类的各个方法通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能代码：

1. 在调用目标方法之前。

2. 在调用目标方法之后。

3. 在嗲偶用目标方法前后。

4. 在处理目标方法异常的catch块中。

分析JVM动态生成的类

1. 创建实现了Collection接口的动态类和查看其名称，分析Proxy.getProxyClass方法的各个参数。

2. 编码列出动态类中的所有构造方法和参数签名。

3. 编码列出动态类中的所有方法和参数签名。

4. 产检动态类的实例对象。

-1.用反射获得构造方法。

-2.编写一个最简单的lnvocationHandler类

-3.调用构造方法创建动态类的实例对象，并将编写的lnvocationHandler类的实例对象传进去。

-4.打印创建的对象和调用对象的没有返回值的方法个getClass方法（调用有返回值的可能会出错），演示调用其他有返回值的方法报告了异常。

-5.将创建的动态类的实例对象的代理修改成匿名内部类的形式编写，锻炼习惯使用匿名内部类。

让JVM创建动态类需要给他提供些什么信息：

1. 生成的类中有哪里方法，通过让其实现哪些接口的方法进行告知。

2. 产生的类字节码必须有一个关联的类加载器对象。

3. 生成的类中的代码是什么样子的，也要由我们来提供，把我们的代码写在一个约定好了的接口对象的方法中，把对象传递给他，他调用我的方法，即相当于插入了我的代码，提供执行代码的对象就是那个InvocationHandler对象，他是在创建动态类的实例对象的构造方法时候传递进去的，在上面的那个InvocationHandler对象的invoke方法中加入一点代码，就可以看到这些代码被调用执行了。

用Proxy.newInstance方法可以直接一步就创建出代理对象。

(转载)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();

12.

13. // 修改账户方法

14. public void updateCount();

15.

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 CountImpl implements Count {

12.

13. @Override

14. public void queryCount() {

15. System.out.println("查看账户方法...");

16.

17. }

18.

19. @Override

20. public void updateCount() {

21. System.out.println("修改账户方法...");

22.

23. }

24.

25. }

26.

27. 、CountProxy.java

28. package net.battier.dao.impl;

29.

30. import net.battier.dao.Count;

31.

32. /**

33. * 这是一个代理类（增强CountImpl实现类）

34. *

35. * @author Administrator

36. *

37. */

38. public class CountProxy implements Count {

39. private CountImpl countImpl;

40.

41. /**

42. * 覆盖默认构造器

43. *

44. * @param countImpl

45. */

46. public CountProxy(CountImpl countImpl) {

47. this.countImpl = countImpl;

48. }

49.

50. @Override

51. public void queryCount() {

52. System.out.println("事务处理之前");

53. // 调用委托类的方法;

54. countImpl.queryCount();

55. System.out.println("事务处理之后");

56. }

57.

58. @Override

59. public void updateCount() {

60. System.out.println("事务处理之前");

61. // 调用委托类的方法;

62. countImpl.updateCount();

63. System.out.println("事务处理之后");

64.

65. }

66.

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 static void main(String[] args) {

14. CountImpl countImpl = new CountImpl();

15. CountProxy countProxy = new CountProxy(countImpl);

16. countProxy.updateCount();

17. countProxy.queryCount();

18.

19. }

20. }

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

7. @Override

8. public void addBook() {

9. System.out.println("增加图书方法。。。");

10. }

11.

12. }

13.

14. 、BookFacadeProxy.java

15.

16. package net.battier.proxy;

17.

18. import java.lang.reflect.InvocationHandler;

19. import java.lang.reflect.Method;

20. import java.lang.reflect.Proxy;

21.

22. /**

23. * JDK动态代理代理类

24. *

25. * @author student

26. *

27. */

28. public class BookFacadeProxy implements 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. }

41.

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. }

55.

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 static void main(String[] args) {

10. BookFacadeProxy proxy = new BookFacadeProxy();

11. BookFacade bookProxy = (BookFacade) proxy.bind(new BookFacadeImpl());

12. bookProxy.addBook();

13. }

14.

15. }

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

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

Java代码

1. package net.battier.dao;

3. public interface BookFacade {

4. public void addBook();

5. }

2、BookCadeImpl1.java

Java代码

1. package net.battier.dao.impl;

3. /**

4. * 这个是没有实现接口的实现类

5. *

6. * @author student