设为首页收藏本站
开启辅助访问

在路上

 找回密码
 立即注册
在路上 › 站点首页 ›学习 › 查看内容

利用java的代理建立缓存

2016-12-20 13:13| 发布者: zhangjf| 查看: 400| 评论: 0

摘要: 背景： 为了实现组件的复用，几乎所有的项目都会调用一个通用的用户组件（org）。各系统和org之间是使用webservice技术进行通，主要是org提供了webservice业务接口。经过了一段时间的使用发现组件相当稳定 ...
背景：

为了实现组件的复用，几乎所有的项目都会调用一个通用的用户组件（org）。各系统和org之间是使用webservice技术进行通，主要是org提供了webservice业务接口。经过了一段时间的使用发现组件相当稳定，正常情况下几乎可以满足所有系统的要求。只是有一个问题比较突出就是当一个方法包含过多的webservice请求时还是会有性能问题，这个问题应该说是webservice的通病。所以这里提供一种解决方法，建立缓存机制。

分析： 首先建立缓存位置其实有两个选择，一是建立在org服务器端，二是建立在客户端。建立在org服务的话可以优化数据库查询的时间，建立在客户端的话可节省调用的时间+数据库查询的时间，所以效率上肯定更高，但是需要付出的代价是需要在每个调用系统中修改相应的代码。 其次建立缓存方式也有所不同，最简单的方式是直接添加一个支持缓存方法，譬如 findCacheUserByDeptId，但是这种方法的缺点也是需要修改过多的代码，所以这里我使用的是通过代理方式实现缓存。优点是只需要修改client的声明方式，无需修改具体调用的代码。
实现步骤：
1 建立一个代理类 新建 IOrgServiceCachePxy 继承InvocationHandler接口
2 实现接口的invoke(Object proxy, Method method, Object[] args) 方法 当被代理class对象的任何业务方法被调用时，这个方法就会被触发。而且这个方法获取这个业务方法的方法信息、参数信息，所以可以轻松实现对这个方法前置、后置操作。相关的缓存操作可以是在改方法中实现的，如果缓存方法比较多的话建议添加多个缓存实现方法，然后根据方法名称分别调用。
3 建立代理对象和实体对象的关联 使用java.lang.reflect.Proxy.newProxyInstance 方法 代理对象的完整代码
  1. package com.megait.orgv2.webservice.cache;
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.InvocationTargetException;
  5. import java.lang.reflect.Method;
  6. import java.lang.reflect.Proxy;
  8. import com.megait.orgv2.webservice.client.model.ArrayOfDepartment;
  9. import com.megait.orgv2.webservice.client.model.ArrayOfUser;
  10. import com.megait.orgv2.webservice.client.model.Department;
  11. import com.megait.orgv2.webservice.client.model.User;
  13. public class IOrgServiceCachePxy implements InvocationHandler {
  14. private Object target;
  15. /**
  16. * 获取代理对象，必须是个实例（在这个对象的基础进行添加其它行为）
  17. * @param target
  18. * @return
  19. */
  20. public Object getProxyInstance(Object target){
  21. this.target = target;
  22. return Proxy.newProxyInstance(target.getClass().getClassLoader(),
  23. target.getClass().getInterfaces(), this);
  24. }
  25. /**
  26. * target 实例，被调用时会触发此方法
  27. * InvocationHandler接口的方法
  28. */
  29. public Object invoke(Object proxy, Method method, Object[] args)
  30. throws Throwable {
  31. Object result = null;
  32. //System.out.println(Thread.currentThread().getName() +": 进入IOrgServiceCachePxy。。。");
  33. if(method.getName().equals("findAllDepartment")){
  34. //System.out.println("args[0]:"+args[0]+",args:[1]"+args[1]+",args[2]:"+args[2]);
  35. result = findAllDepartment(method, args);
  36. }else if(method.getName().equals("findDeptByActDeptId")){
  37. // System.out.println("args[0]:"+args[0]+",args[1]:"+args[1]);
  38. result = findDeptByActDeptId(method, args);
  39. }else if(method.getName().equals("findUserByUserId")){
  40. result = findUserByUserId(method, args);
  41. }else if(method.getName().equals("findUserByDeptId")){
  42. result = findUserByDeptId(method, args);
  43. }else{ //非过滤条件
  44. result = method.invoke(target, args);
  45. }
  46. // System.out.println(Thread.currentThread().getName() +": 22222222222222222");
  47. // System.out.println("after target method...");
  48. return result;
  49. }
  51. // 获得所有的部门
  52. private Object findAllDepartment(Method method, Object[] args)
  53. throws IllegalAccessException, InvocationTargetException {
  54. Object result;
  55. // 只有符合参数要求的方法才会进行缓存处理（只对获取当前有效部门列表）
  56. if(args[0].equals("0") && args[1].equals("y") && args[2].equals(0)){
  57. // System.out.println(Thread.currentThread().getName() +": 进入IOrgServiceCachePxy。。。2");
  58. //System.out.println("方法可进行缓存");
  59. String key = "findAllDepartment_0_y_0";
  60. if(OrgCachePools.allDeptPools.containsKey(key)){
  61. //System.out.println("从缓存中获取"+key);
  62. return OrgCachePools.allDeptPools.get(key);
  63. }
  64. result = method.invoke(target, args);
  65. final ArrayOfDepartment arrayDept = (ArrayOfDepartment)result;
  66. OrgCachePools.allDeptPools.put(key, arrayDept);
  67. }else{
  68. //System.out.println(Thread.currentThread().getName() +": 进入IOrgServiceCachePxy。。。3");
  69. //System.out.println("不符合缓存条件");
  70. result = method.invoke(target, args);
  71. }
  72. return result;
  73. }
  75. // 获得部门对象 根据实体id
  76. private Object findDeptByActDeptId(Method method, Object[] args)
  77. throws IllegalAccessException, InvocationTargetException {
  78. Object result;
  79. // 只有符合参数要求的方法才会进行缓存处理（只对获取当前有效部门列表）
  80. if(args[1].equals(0) ){
  81. // System.out.println(Thread.currentThread().getName() +": 进入IOrgServiceCachePxy。。。2");
  82. //System.out.println("方法可进行缓存");
  83. String key = args[0]+"_0";
  84. if(OrgCachePools.deptPools.containsKey(key)){
  85. // System.out.println("从缓存中获取"+key);
  86. return OrgCachePools.deptPools.get(key);
  87. }
  88. result = method.invoke(target, args);
  89. if(result!=null){
  90. Department dept = (Department)result;
  91. OrgCachePools.deptPools.put(key, dept);
  92. }
  93. }else{
  94. //System.out.println(Thread.currentThread().getName() +": 进入IOrgServiceCachePxy。。。3");
  95. // System.out.println("方法参数不符");
  96. result = method.invoke(target, args);
  97. }
  98. return result;
  99. }
  101. // 获得用户对象
  102. private Object findUserByUserId(Method method, Object[] args)
  103. throws IllegalAccessException, InvocationTargetException {
  104. Object result;
  105. // 只有符合参数要求的方法才会进行缓存处理（只对获取当前有效部门列表）
  106. if(args[1].equals(0) ){
  107. // System.out.println(Thread.currentThread().getName() +": 进入IOrgServiceCachePxy。。。2");
  108. //System.out.println("方法可进行缓存");
  109. String key = args[0]+"_0";
  110. if(OrgCachePools.userPools.containsKey(key)){
  111. // System.out.println("从缓存中获取"+key);
  112. return OrgCachePools.userPools.get(key);
  113. }
  114. result = method.invoke(target, args);
  115. User dept = (User)result;
  116. OrgCachePools.userPools.put(key, dept);
  117. }else{
  118. //System.out.println(Thread.currentThread().getName() +": 进入IOrgServiceCachePxy。。。3");
  119. // System.out.println("方法参数不符");
  120. result = method.invoke(target, args);
  121. }
  122. return result;
  123. }
  125. // 获得用户对象
  126. private Object findUserByDeptId(Method method, Object[] args)
  127. throws IllegalAccessException, InvocationTargetException {
  128. Object result;
  129. // 只有符合参数要求的方法才会进行缓存处理（只对获取当前有效部门列表）
  130. if(args[1].equals("y") ){
  131. // System.out.println(Thread.currentThread().getName() +": 进入IOrgServiceCachePxy。。。2");
  132. //System.out.println("方法可进行缓存");
  133. String key = args[0]+"_y";
  134. if(OrgCachePools.deptUserPools.containsKey(key)){
  135. // System.out.println("从缓存中获取"+key);
  136. return OrgCachePools.deptUserPools.get(key);
  137. }
  138. result = method.invoke(target, args);
  139. ArrayOfUser userList = (ArrayOfUser)result;
  140. OrgCachePools.deptUserPools.put(key, userList);
  141. }else{
  142. //System.out.println(Thread.currentThread().getName() +": 进入IOrgServiceCachePxy。。。3");
  143. // System.out.println("方法参数不符");
  144. result = method.invoke(target, args);
  145. }
  146. return result;
  147. }
  152. }
复制代码

调用代码的差别
  1. // 原来的代码
  2. IOrgServiceClient client = new IOrgServiceClient();
  3. IOrgServicePortType service = client.getIOrgServiceHttpPort();
  5. ArrayOfUser userArr = service.findUserByDeptId(bgsVerid, "y");
  8. // 缓存代码
  9. IOrgServiceClient client = new IOrgServiceClient();
  10. IOrgServiceCachePxy proxy = new IOrgServiceCachePxy();
  11. cacheService = (IOrgServicePortType)proxy.getProxyInstance(client.getIOrgServiceHttpPort());
  13. ArrayOfUser userArr = service.findUserByDeptId(bgsVerid, "y");
复制代码

收藏 邀请
上一篇：使用 Apache Commons CLI 开发命令行工具示例下一篇：JVM：32G以上的堆会发生什么

最新评论

相关分类

小黑屋|在路上 ( 蜀ICP备15035742号-1 )  

;

GMT+8, 2025-7-8 07:06

Copyright 2015-2025 djqfx

返回顶部