bos 第5天(定区的添加、定区的分页查询、hessian远程调用实现获取客户信息)
时间： 22:02:40
&&&& 阅读：221
&&&& 评论：
&&&& 收藏：0
标签：&&&&&&&&&&&&&&&&&&&&&&&&&&&BOS项目笔记 第天
今天内容安排：
1、添加定区功能
2、定区分页查询
3、入门远程调用技术
4、基于实现定区关联客户
1.&添加定区
定区可以将取派员、分区、客户信息关联到一起。
页面：WEB-INF/pages/base/decidedzone.jsp
第一步：使用下拉框展示取派员数据，修改combobox的地址，发送请求
第二步：在StaffAction中提供方法，查询没有作废的取派员，返回数据
第三步：在StaffService中提供方法查询没有作废的取派员
第四步：在BaseDao中提供通用的条件查询方法
第五步：使用datagrid展示未关联到定区的分区数据
第六步：在SubareaAction中提供方法，查询未关联到定分区的分区数据，返回
Service代码：
第七步：为添加定区窗口中的保存按钮绑定事件
第八步：提交上面的添加定区表单，id名称冲突
第九步：在Subarea类中提供方法，返回的中含有字段
第十步：创建定区管理的Action,提供方法保存定区，提供数组属性接收多个分区
Service代码：
第十一步：配置struts.xml
2.&定区分页查询
l&页面修改datagrid的：
l&在定区Action中提供分页查询方法
修改Decidedzone.hbm.xml：
3.&hessian入门
Hessian是一个轻量级的工具，使用简单的方法提供了的功能。 相比，更简单、快捷。采用的是二进制协议，因为采用的是二进制协议，所以它很适合于发送二进制数据。
常见的远程调用的技术：
3、协议、二进制数据
4、阿里巴巴
hessian有两种发布服务的方式：
1、使用框架自己提供的发布
2、和整合发布服务
入门案例参见“入门案例”
4.&定区关联客户
4.1&发布crm服务
第一步：创建动态的web项目，导入的
第二步：创建一个crm数据库和表
第三步：在web.xml中配置spring的DispatcherServlet
第四步：提供接口CustomerService和类、映射文件
第五步：为上面的CustomerService接口提供实现类
第六步：在WEB-INF目录提供的配置文件remoting-servlet.xml
4.2&在bos项目中调用服务获得客户数据
第一步：在bos项目中导入的
第二步：从crm项目中复制接口和类到项目中
第三步：在spring配置文件中配置一个代理对象，可以调用服务
第四步：将上面的代理对象通过注解方式注入到Action中
第五步：为定区列表页面中的“关联客户”按钮绑定事件，发送次请求访问，在中调用代理对象，通过代理对象可以远程访问获取客户数据
//全局变量，定区选中的定区id
function&doAssociations(){
//判断当前是否选中了一个定区
var&rows = $("#grid").datagrid("getSelections");
if(rows.length == 1){
id = rows[0].
//选中了一个
$(‘#customerWindow‘).window(‘open‘);
$("#noassociationSelect").empty();//清空下拉框
$("#associationSelect").empty();//清空下拉框
//发送ajax请求获取没有关联到定区的客户
var&url1 = "${pageContext.request.contextPath}/decidedzoneAction_findnoassociationCustomers.action";
$.post(url1,{},function(data){
//解析json数据，填充到下拉框中
///////////////
for(var&i=0;i&data.i++){
var&id&= data[i].
var&name = data[i].
$("#noassociationSelect").append("&option value=‘"+id+"‘&"+name+"&/option&");
},‘json‘);
//发送ajax请求获取关联到当前选中定区的客户
var&url2 = "${pageContext.request.contextPath}/decidedzoneAction_findhasassociationCustomers.action";
$.post(url2,{"id":rows[0].id},function(data){
//解析json数据，填充到下拉框中
///////////////
for(var&i=0;i&data.i++){
var&id&= data[i].
var&name = data[i].
$("#associationSelect").append("&option value=‘"+id+"‘&"+name+"&/option&");
},‘json‘);
$.messager.alert("提示信息","请选择一个定区操作！","warning");
第六步：为左右移动按钮绑定事件
第七步：为关联客户窗口中的“关联客户”按钮绑定事件
第八步：在定区Action中接收提交的参数，调用服务实现定区关联客户业务功能
&标签：&&&&&&&&&&&&&&&&&&&&&&&&&&&原文：/wujizun/p/6926031.html
教程昨日排行
&&国之画&&&& &&&&&&
&& &&&&&&&&&&&&&&
鲁ICP备号-4
打开技术之扣，分享程序人生！jdbchelper（2）
public class DBUtil {
* 获取数据库连接
private static Connection getConnection(){
String url = &jdbc:mysql://localhost:3306/test1&;
String user = &root&;
String password = &root&;
String driverClass =&com.mysql.jdbc.Driver&;
Connection con =
Class.forName(driverClass);
} catch (ClassNotFoundException e) {
System.out.println(&驱动加载失败&);
e.printStackTrace();
con = DriverManager.getConnection(url, user, password);
} catch (SQLException e) {
e.printStackTrace();
* 关闭数据库资源
public static void close(Connection con ,PreparedStatement ps,ResultSet rs){
if(con!=null){
con.close();
} catch (SQLException e) {
e.printStackTrace();
if(ps!=null){
ps.close();
} catch (SQLException e) {
e.printStackTrace();
if(rs!=null){
rs.close();
} catch (SQLException e) {
e.printStackTrace();
* 获取查询数据
public static List&Map&String,Object&& getData(String sql ,Object...arrays){
List&Map&String,Object&&
list = new ArrayList&Map&String,Object&&();
Connection con =
getConnection();
PreparedStatement ps=
ResultSet rs =
ps = con.prepareStatement(sql);
if(arrays!=null){
for(int i=0;i&arrays.i++){
ps.setObject(i+1, arrays[i]);
rs = ps.executeQuery();
int size = rs.getMetaData().getColumnCount();
while(rs.next()){
Map&String,Object& map = new HashMap&String, Object&();
for(int i=0;i&i++){//每一行作为一个map
String columnName = rs.getMetaData().getColumnLabel(i+1); //获取查询结果的字段名称
Object columnValue = rs.getObject(i+1);//字段名称对应的值
map.put(columnName, columnValue);
list.add(map);
} catch (SQLException e) {
e.printStackTrace();
close(con,ps,rs);
* 更新数据（增，删，改）
public static void updateData(String sql ,Object...arrays){
Connection con = getConnection();
PreparedStatement ps=
if(con!=null){
ps = con.prepareStatement(sql);
if(ps!=null){
if(arrays!=null){
for(int i=0;i&arrays.i++)//设置sql语句中的参数值
ps.setObject(i+1, arrays[i]);
ps.executeUpdate();
System.out.println(&语句执行失败&);
} catch (SQLException e) {
e.printStackTrace();
close(con,ps,null);
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：119342次
积分：2107
积分：2107
排名：第18920名
原创：95篇
转载：96篇
评论：16条
(10)(1)(1)(3)(9)(3)(6)(10)(6)(4)(10)(4)(18)(3)(2)(4)(3)(4)(4)(9)(4)(2)(3)(7)(2)(1)(2)(4)(5)(17)(1)(1)(4)(14)(9)(1)
(window.slotbydup = window.slotbydup || []).push({
id: '4740887',
container: s,
size: '250,250',
display: 'inlay-fix'Neo4j图数据库管理系统开发笔记之三：构建安全的RMI Service（Client） - 北方客 - 博客园
随笔 - 20, 文章 - 0, 评论 - 73, 引用 - 0
最初，设计RMI Service主要是基于三个目的。第一，解决Neo4j嵌入式图数据库单例模式的境况，实现多个客户端可同时操作同一数据库。第二，为图数据库添加安全认证机制，保证数据库访问的安全性。第三，提供轻量级的数据访问接口文件（Neo4j本身提供的Java API Jar文件合计有40多MB），而封装后的RMI Client Jar文件只有300KB左右。
3.1. RMI Client（客户端）
首先介绍下RMI Client（客户端），因为RMI服务中的绝大部分公共对象都在Client包里面，在项目关系上，也是RMI Server端引用RMI Client客户端。项目目录结构图如下所示：
3.1.1 客户端示例
在开始介绍RMI客户端实现原理之前，我们先来浏览下客户端调用方面的代码示例。
3.1.1.1 初始化RMI服务部署地址信息
利用RMI客户端调用RMI服务的第一步，是先初始化RMI服务部署的地址和端口信息，否则，客户端将无法定位到远程服务。示例代码如下。
String hostAddress = &10.230.9.145&;
String hostPort = &1099&;
for(String serviceName : RemoteServiceUtil.getRemoteServiceList().keySet()) {
RemoteClientFactory.initRemoteServiceOption(serviceName, hostAddress, hostPort);
3.1.1.2 初始化RMI客户端用户信息
由客户端将用户名称和密码传递到服务端，在服务端进行用户权限认证（登录用户详细资料以及权限配置信息都由服务端配置管理）。示例代码如下所示：
RemoteClientFactory.setLoginName(loginName);
RemoteClientFactory.setLoginPassword(password);
3.1.1.3 获取远程服务实例
其实，用户登录认证工作是在获取远程服务实例的时候进行的，如果认证成功，则返回对应的服务实例，否则将抛出异常信息。
private IGraphNodeService graphNodeService = null;
this.graphNodeService = RemoteClientFactory.getGraphNodeService(selectedGraphName);
GNode startNode = this.graphNodeService.findNodeByID(10);
3.1.2 远程服务实体类
对Neo4j Java API中的关键实体对象进行封装处理，保证其可实现完全意义上的序列化。封装完成后，Client端将不会出现Neo4j Java API中原生的接口类对象，所有的数据都将在RMI Server（服务端）通过解析，自动转换成RMI Client（客户端）认可的类对象。其封装映射关系如下图所示：
3.1.2.1 GNode
package com.hnepri.neo4j.client.rmi.
import java.io.S
import java.util.ArrayL
import java.util.HashM
import java.util.L
import java.util.M
* Description: Neo4j图数据库节点实体信息类&br&
* Copyright: Copyright (c) 2015&br&
* Company: 河南电力科学研究院智能电网所&br&
* @author shangbingbing 编写
* @version 1.0
public class GNode implements Serializable {
private static final long serialVersionUID = 1L;
private long id = -1;
private int degree = 0;
private Map&String,Object& propertyList = new HashMap&String,Object&();
private List&String& labelNameList = new ArrayList&String&();
private List&Long& relationshipList = new ArrayList&Long&();
private Map&String,ArrayList&Long&& relationshipTypeList = new HashMap&String,ArrayList&Long&&();
private Map&String,ArrayList&Long&& relationshipDirectionList = new HashMap&String,ArrayList&Long&&();
* 获取节点编码
public long getId() {
* 设置节点编码
* @param id
public void setId(long id) {
* 获取节点深度
public int getDegree() {
* 设置节点深度
* @param degree
public void setDegree(int degree) {
this.degree =
* 获取节点属性集合
public Map&String, Object& getPropertyList() {
return propertyL
* 获取节点标签集合
public List&String& getLabelNameList() {
return labelNameL
* 获取节点关联关系编码集合
public List&Long& getRelationshipList() {
return relationshipL
* 获取节点的关联关系类型分组集合
public Map&String,ArrayList&Long&& getRelationshipTypeList() {
return relationshipTypeL
* 获取节点的关联关系方向分组集合
public Map&String,ArrayList&Long&& getRelationshipDirectionList() {
return relationshipDirectionL
* 根据关系类型获取对应关系编码集合。
* @param relationshipType
public List&Long& getRelationships(String relationshipType) {
if(this.relationshipTypeList.containsKey(relationshipType)) {
return this.relationshipTypeList.get(relationshipType);
return new ArrayList&Long&();
* 根据关系方向获取对应关系编码集合。
* @param direction
public List&Long& getRelationships(GDirection direction) {
if(this.relationshipDirectionList.containsKey(direction.getName())) {
return this.relationshipDirectionList.get(direction.getName());
return new ArrayList&Long&();
* 根据关系类型和方向检索出关系编码集合。
* @param relationshipType
* @param direction
public List&Long& getRelationships(String relationshipType, GDirection direction) {
List&Long& listByType = this.getRelationships(relationshipType);
List&Long& listByDirection = this.getRelationships(direction);
List&Long& list = new ArrayList&Long&();
for(long id : listByType) {
if(listByDirection.contains(id)) {
list.add(id);
3.1.2.2 GRelationship
package com.hnepri.neo4j.client.rmi.
import java.io.S
import java.util.HashM
import java.util.M
* Description: Neo4j图数据库连接关系实体信息类&br&
* Copyright: Copyright (c) 2015&br&
* Company: 河南电力科学研究院智能电网所&br&
* @author shangbingbing 编写
* @version 1.0
public class GRelationship implements Serializable {
private static final long serialVersionUID = 1L;
private long id = -1;
private String relationshipType = "";
private long startNodeID = -1;
private long endNodeID = -1;
private Map&String,Object& propertyList = new HashMap&String,Object&();
* 获取关系编码
public long getId() {
* 设置关系编码
* @param id
public void setId(long id) {
* 获取关系类型
public String getRelationshipType() {
return relationshipT
* 设置关系类型
* @param relationshipType
public void setRelationshipType(String relationshipType) {
this.relationshipType = relationshipT
* 获取起始节点编码
public long getStartNodeID() {
return startNodeID;
* 设置起始节点编码
* @param startNodeID
public void setStartNodeID(long startNodeID) {
this.startNodeID = startNodeID;
* 获取结束节点编码
public long getEndNodeID() {
return endNodeID;
* 设置结束节点编码
* @param endNodeID
public void setEndNodeID(long endNodeID) {
this.endNodeID = endNodeID;
* 获取关系属性信息集合
public Map&String, Object& getPropertyList() {
return propertyL
* 设置关系属性信息集合
* @param propertyList
public void setPropertyList(Map&String, Object& propertyList) {
this.propertyList = propertyL
3.1.2.3 GPath
package com.hnepri.neo4j.client.rmi.
import java.io.S
import java.util.ArrayL
import java.util.L
* Description: Neo4j图数据库路径实体信息类&br&
* Copyright: Copyright (c) 2015&br&
* Company: 河南电力科学研究院智能电网所&br&
* @author shangbingbing 编写
* @version 1.0
public class GPath implements Serializable {
private static final long serialVersionUID = 1L;
private GNode beginNode = null;
private GNode endNode = null;
private List&GNode& nodes = new ArrayList&GNode&();
private List&GNode& reverseNodes = new ArrayList&GNode&();
private List&GRelationship& relationships = new ArrayList&GRelationship&();
private List&GRelationship& reverseRelationships = new ArrayList&GRelationship&();
private GRelationship lastRelationship = null;
* 获取路径中包含的Node对象集合。
public List&GNode& getNodes() {
* 获取路径中包含的Relationship对象集合。
public List&GRelationship& getRelationships() {
* 获取路径的起始节点对象。
public GNode getBeginNode() {
if(this.nodes.size() & 0) {
this.beginNode = this.nodes.get(0);
return beginN
* 获取路径的结束节点对象。
public GNode getEndNode() {
if(this.nodes.size() & 0) {
this.endNode = this.nodes.get(this.nodes.size() - 1);
return endN
* 获取路径中包含的Node对象集合（反向）。
public List&GNode& getReverseNodes() {
if(this.nodes.size() & 0) {
this.reverseNodes.clear();
for(int i=this.nodes.size() - 1; i&=0; i--) {
this.reverseNodes.add(this.nodes.get(i));
return reverseN
* 获取获取路径中包含的Relationship对象集合（反向）。
public List&GRelationship& getReverseRelationships() {
if(this.relationships.size() & 0) {
this.reverseRelationships.clear();
for(int i=this.relationships.size() - 1; i&=0; i--) {
this.reverseRelationships.add(this.relationships.get(i));
return reverseR
* 获取获取路径中最后一个Relationship对象。
public GRelationship getLastRelationship() {
if(this.relationships.size() & 0) {
this.lastRelationship = this.relationships.get(this.relationships.size() - 1);
return lastR
3.1.2.4 GDirection
package com.hnepri.neo4j.client.rmi.
import java.io.S
* Description: Neo4j图数据库关系方向类型信息类&br&
* Copyright: Copyright (c) 2015&br&
* Company: 河南电力科学研究院智能电网所&br&
* @author shangbingbing 编写
* @version 1.0
public class GDirection implements Serializable {
private static final long serialVersionUID = 1L;
* 包含两种方向。
public static final String BOTH = "BOTH";
* incoming方向。
public static final String INCOMING = "INCOMING";
* outgoing方向。
public static final String OUTGOING = "OUTGOING";
* 获取关系方向名称。
public String getName() {
private GDirection(String name) {
this.name =
* 生成BOTH类型的GDirection对象
public static GDirection both() {
GDirection direction = new GDirection(BOTH);
* 生成INCOMING类型的GDirection对象
public static GDirection incoming() {
GDirection direction = new GDirection(INCOMING);
* 生成OUTGOING类型的GDirection对象
public static GDirection outgoing() {
GDirection direction = new GDirection(OUTGOING);
3.1.2.5 GOrderBy
package com.hnepri.neo4j.client.rmi.
import java.io.S
* Description: Neo4j图数据库排序信息类&br&
* Copyright: Copyright (c) 2015&br&
* Company: 河南电力科学研究院智能电网所&br&
* @author shangbingbing 编写
* @version 1.0
public class GOrderBy implements Serializable {
private static final long serialVersionUID = 1L;
* 排序类型字符串：升序
public static final String ORDER_TYPE_ASC = "ASC";
* 排序类型字符串：降序
public static final String ORDER_TYPE_DESC = "DESC";
private String propertyN
private String orderT
* 获取参与排序的属性名称
public String getPropertyName() {
return propertyN
* 获取排序类型
public String getOrderType() {
return this.orderT
* 构造函数
* @param propertyName 排序属性名称
* @param orderType 排序类型
private GOrderBy(String propertyName, String orderType) {
this.propertyName = propertyN
this.orderType = orderT
* 构建升序排序信息对象
* @param propertyName
public static GOrderBy asc(String propertyName) {
return new GOrderBy(propertyName, ORDER_TYPE_ASC);
* 构建降序排序信息对象
* @param propertyName
public static GOrderBy desc(String propertyName) {
return new GOrderBy(propertyName, ORDER_TYPE_DESC);
3.1.2.6 GPage
package com.hnepri.neo4j.client.rmi.
import java.io.S
import java.text.DecimalF
import java.util.ArrayL
import java.util.L
import mon.util.LogInfoU
* Description: 图数据库数据分页模型类。&br&
* 利用此类可分页管理Node数据和Relationship数据等。
* Copyright: Copyright (c) 2015&br&
* Company: 河南电力科学研究院智能电网所&br&
* @author shangbingbing 编写
* @version 1.0
public class GPage implements Serializable {
private static final long serialVersionUID = 946538L;
private int pageSize = 10;
private int pageIndex = 1;
private int prevPageIndex = 1;
private int nextPageIndex = 1;
private int pageCount = 0;
private int pageFirstRowIndex = 1;
private boolean hasNextPage = true;
private int totalCount = 0;
private long startTime = System.currentTimeMillis();
private long endTime = System.currentTimeMillis();
private List&GNode& nodeList = new ArrayList&GNode&();
private List&GRelationship& relationshipList = new ArrayList&GRelationship&();
* 分页对象构造函数
* @param pageSize 每页记录数
public GPage(int pageSize) {
this.pageSize = pageS
* 获取分页记录数量
public int getPageSize() {
return pageS
* 获取当前页序号
public int getPageIndex() {
return pageI
* 设置当前页序号
* @param pageIndex
public void setPageIndex(int pageIndex) {
if(pageIndex &= 0) {
pageIndex = 1;
this.pageIndex = pageI
* 获取分页总数
public int getPageCount() {
if(this.getTotalCount() == 0) {
this.pageCount = 0;
int shang = this.getTotalCount() / this.getPageSize();
int yu = this.getTotalCount() % this.getPageSize();
if(yu & 0) {
shang += 1;
this.pageCount =
return pageC
* 获取每页的第一行序号
public int getPageFirstRowIndex() {
this.pageFirstRowIndex = (this.pageIndex - 1) * this.getPageSize() + 1;
return pageFirstRowI
* 获取上一页序号
public int getPrevPageIndex() {
if(this.pageIndex & 1) {
this.prevPageIndex = this.pageIndex - 1;
this.prevPageIndex = 1;
return prevPageI
* 获取下一页序号
public int getNextPageIndex() {
if(this.pageIndex & this.pageCount) {
this.nextPageIndex = this.pageIndex + 1;
this.nextPageIndex = this.pageC
return nextPageI
* 跳转到下一页
public void nextPage() {
if(this.totalCount == 0 || this.getPageCount() == 0) {
this.pageIndex = 1;
if(this.pageIndex & this.pageCount) {
this.pageIndex = this.pageIndex + 1;
this.pageIndex = this.pageC
* 跳转到上一页
public void prevPage() {
if(this.pageIndex & 1) {
this.pageIndex = this.pageIndex - 1;
this.pageIndex = 1;
* 获取是否有下一页
public boolean isHasNextPage() {
if(this.pageIndex & this.getPageCount()) {
this.hasNextPage = true;
this.hasNextPage = false;
return hasNextP
* 获取总记录数
public int getTotalCount() {
return totalC
* 获取总记录数
* @param totalCount
public void setTotalCount(int totalCount) {
this.totalCount = totalC
* 初始化起始时间（毫秒）
public void initStartTime() {
this.startTime = System.currentTimeMillis();
* 初始化截止时间（毫秒）
public void initEndTime() {
this.endTime = System.currentTimeMillis();
* 获取毫秒格式的耗时信息
public String getTimeIntervalByMilli() {
return String.valueOf(this.endTime - this.startTime) + "毫秒";
* 获取秒格式的耗时信息
public String getTimeIntervalBySecond() {
double interval = (this.endTime - this.startTime)/1000.0;
DecimalFormat df = new DecimalFormat("#.##");
return df.format(interval) + "秒";
* 打印时间信息
public void printTimeInfo() {
LogInfoUtil.printLog("起始时间：" + this.startTime);
LogInfoUtil.printLog("截止时间：" + this.endTime);
LogInfoUtil.printLog("耗费时间：" + this.getTimeIntervalBySecond());
* 获取Node检索结果列表
public List&GNode& getNodeList() {
return nodeL
* 获取Relationship检索结果列表
public List&GRelationship& getRelationshipList() {
return relationshipL
3.1.3 远程服务接口类
这里着重介绍下远程服务基础接口IBaseRemoteService，主要有两个方法，分别进行用户登录验证和传递图数据库名称等。用户登录验证，是RMI安全机制的第一步，决定RMI客户端是否有权使用RMI服务。
package com.hnepri.neo4j.client.rmi.
import java.rmi.R
import java.rmi.RemoteE
* Description: 远程服务基类接口类&br&
* Copyright: Copyright (c) 2015&br&
* Company: 河南电力科学研究院智能电网所&br&
* @author shangbingbing 编写
* @version 1.0
public interface IBaseRemoteService extends Remote {
* Remote连接测试，正常情况会返回大写的SUCCESS。
* @throws RemoteException
public String remoteTest() throws RemoteE
* 验证RMI服务用户信息
* @param loginName 用户名称
* @param password 用户密码
* @return 返回状态值。&br&
* 0：表示验证通过。&br&
* 1：表示未设置用户或者密码。&br&
* 2：表示用户不存在。&br&
* 3：表示密码错误。&br&
* 4：表示用户无权访问此服务。&br&
* 5：表示IP无权访问此服务。
* @throws RemoteException
public int login(String loginName, String password) throws RemoteE
* 初始化设置图数据库名称
* @param graphName 图数据库名称（与Server端保持一致）
* @throws RemoteException
public void initGraphName(String graphName) throws RemoteE
* 初始化设置图数据库路径
* @param graphPath 图数据库路径（与Server端保持一致）
* @throws RemoteException
public void initGraphPath(String graphPath) throws RemoteE
由于每个接口文件中的方法过多，这里不再一一罗列，开发人员可以根据自己的需要创建相关的接口文件和接口中的方法。其他几个服务接口类如下所示：
package com.hnepri.neo4j.client.rmi.
import java.rmi.RemoteE
import java.util.HashM
import java.util.L
import java.util.M
import com.hnepri.neo4j.client.form.graph.bean.GraphConfigO
import com.hnepri.neo4j.client.form.graph.bean.GraphModelO
* Description: Neo4j图数据库管理操作接口&br&
* Copyright: Copyright (c) 2015&br&
* Company: 河南电力科学研究院智能电网所&br&
* @author shangbingbing 编写
* @version 1.0
public interface IGraphManageService extends IBaseRemoteService
package com.hnepri.neo4j.client.rmi.
import java.rmi.RemoteE
import java.util.L
import java.util.M
import com.hnepri.neo4j.client.rmi.bean.GN
import com.hnepri.neo4j.client.rmi.bean.GR
* Description: Neo4j图数据库Node操作接口&br&
* Copyright: Copyright (c) 2015&br&
* Company: 河南电力科学研究院智能电网所&br&
* @author shangbingbing 编写
* @version 1.0
public interface IGraphNodeService extends IBaseRemoteService
package com.hnepri.neo4j.client.rmi.
import java.rmi.RemoteE
import java.util.HashM
import java.util.L
import com.hnepri.neo4j.client.rmi.bean.GN
import com.hnepri.neo4j.client.rmi.bean.GR
* Description: Neo4j图数据库Index操作接口&br&
* Copyright: Copyright (c) 2015&br&
* Company: 河南电力科学研究院智能电网所&br&
* @author shangbingbing 编写
* @version 1.0
public interface IGraphIndexService extends IBaseRemoteService
package com.hnepri.neo4j.client.rmi.
import java.rmi.RemoteE
import java.util.L
import com.hnepri.neo4j.client.rmi.bean.GD
import com.hnepri.neo4j.client.rmi.bean.GP
* Description: Neo4j图数据库Path操作接口&br&
* Copyright: Copyright (c) 2015&br&
* Company: 河南电力科学研究院智能电网所&br&
* @author shangbingbing 编写
* @version 1.0
public interface IGraphPathService extends IBaseRemoteService
package com.hnepri.neo4j.client.rmi.
import java.rmi.RemoteE
import java.util.L
import java.util.M
import java.util.P
import com.hnepri.neo4j.client.rmi.bean.GD
import com.hnepri.neo4j.client.rmi.bean.GN
import com.hnepri.neo4j.client.rmi.bean.GOrderBy;
import com.hnepri.neo4j.client.rmi.bean.GP
import com.hnepri.neo4j.client.rmi.bean.GP
import com.hnepri.neo4j.client.rmi.bean.GR
* Description: Neo4j图数据库Cypher操作接口&br&
* Copyright: Copyright (c) 2015&br&
* Company: 河南电力科学研究院智能电网所&br&
* @author shangbingbing 编写
* @version 1.0
public interface IGraphCypherService extends IBaseRemoteService
3.1.4 远程服务工具类
远程服务工具类包括客户端调用工厂Factory类（主要是对远程服务接口类的调用进行组织管理，同时提供安全认证机制，确保调用者为认证和授权用户）、远程登录状态工具类、远程服务信息工具类等。
&3.1.4.1 RemoteClientFactory
package com.hnepri.neo4j.client.rmi.
import java.io.S
import java.net.InetA
import java.net.UnknownHostE
import java.rmi.N
import java.util.HashM
import mon.util.LogInfoU
import com.hnepri.neo4j.client.rmi.service.IGraphCypherS
import com.hnepri.neo4j.client.rmi.service.IGraphIndexS
import com.hnepri.neo4j.client.rmi.service.IGraphManageS
import com.hnepri.neo4j.client.rmi.service.IGraphNodeS
import com.hnepri.neo4j.client.rmi.service.IGraphPathS
* Description: Hadoop集群相关rmi服务客户端工厂类&br&
* Copyright: Copyright (c) 2015&br&
* Company: 河南电力科学研究院智能电网所&br&
* @author shangbingbing 编写
* @version 1.0
public class RemoteClientFactory {
* 远程服务调用成功返回值
public static final String REMOTE_CALL_STATUS_SUCCESS = "SUCCESS";
* 远程服务调用失败返回值
public static final String REMOTE_CALL_STATUS_FAILURE = "FAILURE";
* RMI服务默认部署主机IP地址
public static final String DEFAULT_HOST_ADDRESS = "10.231.45.34";
* RMI服务默认部署主机端口号
public static final String DEFAULT_HOST_PORT = "1099";
private static String loginName = "";
private static String loginPassword = "";
获取登录用户名称
public static String getLoginName() {
return loginN
* 设置登录用户名称
* @param loginName
public static void setLoginName(String loginName) {
RemoteClientFactory.loginName = loginN
remoteServiceLoginStatusList.clear();
* 获取登录用户密码
public static String getLoginPassword() {
return loginP
* 设置登录用户密码
* @param loginPassword
public static void setLoginPassword(String loginPassword) {
RemoteClientFactory.loginPassword = loginP
remoteServiceLoginStatusList.clear();
* 远程服务登录验证状态列表
private static HashMap&String,Integer& remoteServiceLoginStatusList = new HashMap&String,Integer&();
private static HashMap&String,RemoteServiceOption& remoteServiceOptionList = new HashMap&String,RemoteServiceOption&();
* 获取远程服务选项配置对象
* @param serviceName
private static RemoteServiceOption getRemoteServiceOption(String serviceName) {
if(remoteServiceOptionList.containsKey(serviceName)) {
return remoteServiceOptionList.get(serviceName);
RemoteServiceOption option = new RemoteServiceOption();
option.setName(serviceName);
option.setTitle(RemoteServiceUtil.getRemoteServiceList().get(serviceName));
option.setHostAddress(DEFAULT_HOST_ADDRESS);
option.setHostPort(DEFAULT_HOST_PORT);
option.setServiceGroup(RemoteServiceGroupUtil.getRemoteServiceMappingGroupList().get(serviceName));
remoteServiceOptionList.put(option.getName(), option);
* 获取客户端IP地址
public static String getClientAddress() {
return InetAddress.getLocalHost().getHostAddress();
} catch (UnknownHostException e) {
return "127.0.0.1";
* 初始化远程服务配置信息（当RMI服务端IP地址和端口发生变更时，可调用此方法更新初始化客户端配置）。
* @param serviceName 远程服务名称
* @param hostAddress 主机IP地址
* @param hostPort 主机端口号
public static void initRemoteServiceOption(String serviceName, String hostAddress, String hostPort) {
if(serviceName == null || serviceName == "") return;
if(RemoteServiceUtil.getRemoteServiceList().containsKey(serviceName) == false) {
LogInfoUtil.printLog(String.format("警告：您要调用的远程服务【%】是不存在的！", serviceName));;
RemoteServiceOption option = getRemoteServiceOption(serviceName);
if(hostAddress != null && hostAddress != "") {
option.setHostAddress(hostAddress);
if(hostPort != null && hostPort != "") {
option.setHostPort(hostPort);
* 解析用户登录返回状态值。
* @param statusValue
public static String parseLoginStatusValue(int statusValue) {
String baseMessage = "警告：未通过RMI服务用户信息验证，您不能访问相关服务！异常原因：";
String msg = "未知的异常错误";
if(RemoteLoginStatusUtil.getRemoteLoginStatusList().containsKey(statusValue)) {
msg = RemoteLoginStatusUtil.getRemoteLoginStatusList().get(statusValue);
return baseMessage + msg + "！";
* &b&获取Neo4j图数据库信息管理操作服务接口。&/b&&br&&br&
* 接口功能包括：&br&
* 1、图数据库信息管理：创建、编辑、删除数据库信息等。&br&
* 2、图数据库模型管理等。&br&
public static IGraphManageService getGraphManageService() {
IGraphManageService service = null;
RemoteServiceOption option = getRemoteServiceOption(RemoteServiceUtil.NEO4J_GRAPH_MANAGE_SERVICE);
String path = option.getRemoteServiceCallPath();
service = (IGraphManageService)Naming.lookup(path);
} catch (Exception e) {
e.printStackTrace();
* &b&获取Neo4j图数据库Node操作服务接口。&/b&&br&&br&
* 接口功能包括：&br&
* 1、Node信息管理：创建、编辑、删除节点信息等。&br&
* 2、Relationship信息管理：创建、编辑、删除关系信息等。&br&
* @param graphName 图数据库名称。
public static IGraphNodeService getGraphNodeService(String graphName) {
IGraphNodeService service = null;
RemoteServiceOption option = getRemoteServiceOption(RemoteServiceUtil.NEO4J_GRAPH_NODE_SERVICE);
String path = option.getRemoteServiceCallPath();
service = (IGraphNodeService)Naming.lookup(path);
int loginStatusValue = RemoteLoginStatusUtil.LOGIN_STATUS_SUCCESS;
if(remoteServiceLoginStatusList.containsKey(RemoteServiceUtil.NEO4J_GRAPH_NODE_SERVICE)) {
loginStatusValue = remoteServiceLoginStatusList.get(RemoteServiceUtil.NEO4J_GRAPH_NODE_SERVICE);
loginStatusValue = service.login(loginName, loginPassword);
if(loginStatusValue == RemoteLoginStatusUtil.LOGIN_STATUS_SUCCESS) {
remoteServiceLoginStatusList.put(RemoteServiceUtil.NEO4J_GRAPH_NODE_SERVICE, RemoteLoginStatusUtil.LOGIN_STATUS_SUCCESS);
if(loginStatusValue == RemoteLoginStatusUtil.LOGIN_STATUS_SUCCESS) {
service.initGraphName(graphName);
throw new Exception(parseLoginStatusValue(loginStatusValue));
} catch (Exception e) {
e.printStackTrace();
* &b&获取Neo4j图数据库Index操作服务接口。&/b&&br&&br&
* 接口功能包括：&br&
* 1、管理Node和Relationship相关的索引信息。&br&
* 2、根据索引查询Node和Relationship信息。&br&
* @param graphName 图数据库名称。
public static IGraphIndexService getGraphIndexService(String graphName) {
IGraphIndexService service = null;
RemoteServiceOption option = getRemoteServiceOption(RemoteServiceUtil.NEO4J_GRAPH_INDEX_SERVICE);
String path = option.getRemoteServiceCallPath();
service = (IGraphIndexService)Naming.lookup(path);
int loginStatusValue = RemoteLoginStatusUtil.LOGIN_STATUS_SUCCESS;
if(remoteServiceLoginStatusList.containsKey(RemoteServiceUtil.NEO4J_GRAPH_INDEX_SERVICE)) {
loginStatusValue = remoteServiceLoginStatusList.get(RemoteServiceUtil.NEO4J_GRAPH_INDEX_SERVICE);
loginStatusValue = service.login(loginName, loginPassword);
if(loginStatusValue == RemoteLoginStatusUtil.LOGIN_STATUS_SUCCESS) {
remoteServiceLoginStatusList.put(RemoteServiceUtil.NEO4J_GRAPH_INDEX_SERVICE, RemoteLoginStatusUtil.LOGIN_STATUS_SUCCESS);
if(loginStatusValue == RemoteLoginStatusUtil.LOGIN_STATUS_SUCCESS) {
service.initGraphName(graphName);
throw new Exception(parseLoginStatusValue(loginStatusValue));
} catch (Exception e) {
e.printStackTrace();
* &b&获取Neo4j图数据库Path操作服务接口。&/b&&br&&br&
* 接口功能包括：&br&
* 1、基于路径等进行的遍历操作。&br&
* @param graphName 图数据库名称。
public static IGraphPathService getGraphPathService(String graphName) {
IGraphPathService service = null;
RemoteServiceOption option = getRemoteServiceOption(RemoteServiceUtil.NEO4J_GRAPH_PATH_SERVICE);
String path = option.getRemoteServiceCallPath();
service = (IGraphPathService)Naming.lookup(path);
int loginStatusValue = RemoteLoginStatusUtil.LOGIN_STATUS_SUCCESS;
if(remoteServiceLoginStatusList.containsKey(RemoteServiceUtil.NEO4J_GRAPH_PATH_SERVICE)) {
loginStatusValue = remoteServiceLoginStatusList.get(RemoteServiceUtil.NEO4J_GRAPH_PATH_SERVICE);
loginStatusValue = service.login(loginName, loginPassword);
if(loginStatusValue == RemoteLoginStatusUtil.LOGIN_STATUS_SUCCESS) {
remoteServiceLoginStatusList.put(RemoteServiceUtil.NEO4J_GRAPH_PATH_SERVICE, RemoteLoginStatusUtil.LOGIN_STATUS_SUCCESS);
if(loginStatusValue == RemoteLoginStatusUtil.LOGIN_STATUS_SUCCESS) {
service.initGraphName(graphName);
throw new Exception(parseLoginStatusValue(loginStatusValue));
} catch (Exception e) {
e.printStackTrace();
* &b&获取Neo4j图数据库Cypher操作服务接口。&/b&&br&&br&
* 接口功能包括：&br&
* 1、基于Cypher进行的查询服务。&br&
* @param graphName 图数据库名称。
public static IGraphCypherService getGraphCypherService(String graphName) {
IGraphCypherService service = null;
//根据服务名称，获取对应的远程服务配置选项实体对象。
RemoteServiceOption option = getRemoteServiceOption(RemoteServiceUtil.NEO4J_GRAPH_CYPHER_SERVICE);
//获取RMI远程服务调用路径，格式如：rmi://127.0.0.1:1099/group/neo4j_cypher_service
String path = option.getRemoteServiceCallPath();
//根据调用路径进行反射处理。
service = (IGraphCypherService)Naming.lookup(path);
//验证用户的登录状态。
int loginStatusValue = RemoteLoginStatusUtil.LOGIN_STATUS_SUCCESS;
//并非每次都需要重新登录验证，系统会自动记录上次登录成功的状态。
if(remoteServiceLoginStatusList.containsKey(RemoteServiceUtil.NEO4J_GRAPH_CYPHER_SERVICE)) {
loginStatusValue = remoteServiceLoginStatusList.get(RemoteServiceUtil.NEO4J_GRAPH_CYPHER_SERVICE);
loginStatusValue = service.login(loginName, loginPassword);
if(loginStatusValue == RemoteLoginStatusUtil.LOGIN_STATUS_SUCCESS) {
remoteServiceLoginStatusList.put(RemoteServiceUtil.NEO4J_GRAPH_CYPHER_SERVICE, RemoteLoginStatusUtil.LOGIN_STATUS_SUCCESS);
if(loginStatusValue == RemoteLoginStatusUtil.LOGIN_STATUS_SUCCESS) {
//如果登录成功，则初始化图数据库名称，并返回接口服务实例。
service.initGraphName(graphName);
//如果登录失败，则将登录异常信息作为异常抛出。
throw new Exception(parseLoginStatusValue(loginStatusValue));
} catch (Exception e) {
e.printStackTrace();
* Description: 远程服务配置选项信息类&br&
* Copyright: Copyright (c) 2015&br&
* Company: 河南电力科学研究院智能电网所&br&
* @author shangbingbing 编写
* @version 1.0
class RemoteServiceOption implements Serializable {
private static final long serialVersionUID = 3224078L;
private String serviceG
private String hostA
private String hostP
public String getName() {
public void setName(String name) {
this.name =
public String getTitle() {
public void setTitle(String title) {
this.title =
public String getServiceGroup() {
return serviceG
public void setServiceGroup(String serviceGroup) {
this.serviceGroup = serviceG
public String getHostAddress() {
return hostA
public void setHostAddress(String hostAddress) {
this.hostAddress = hostA
public String getHostPort() {
return hostP
public void setHostPort(String hostPort) {
this.hostPort = hostP
public String getRemoteServiceCallPath() {
String basePath = "rmi://%s:%s/%s/%s";
return String.format(basePath, this.getHostAddress(), this.getHostPort(), this.getServiceGroup(), this.getName());
* Description: 远程服务分组工具类&br&
* Copyright: Copyright (c) 2015&br&
* Company: 河南电力科学研究院智能电网所&br&
* @author shangbingbing 编写
* @version 1.0
class RemoteServiceGroupUtil {
* 服务分组标示：neo4j服务
protected static final String SERVICE_GROUP_NEO4J = "-bdfc-4200-adf6-82d";
* 服务分组标示：公共服务
protected static final String SERVICE_GROUP_COMMON = "1f649bda-94e7-408d-8f17-7e7a59337f77";
private static HashMap&String,String& remoteServiceMappingGroupList = null;
* 远程服务与服务组映射列表
public static HashMap&String,String& getRemoteServiceMappingGroupList() {
if(remoteServiceMappingGroupList == null) {
remoteServiceMappingGroupList = new HashMap&String,String&();
remoteServiceMappingGroupList.put(RemoteServiceUtil.NEO4J_GRAPH_MANAGE_SERVICE, SERVICE_GROUP_NEO4J);
remoteServiceMappingGroupList.put(RemoteServiceUtil.NEO4J_GRAPH_NODE_SERVICE, SERVICE_GROUP_NEO4J);
remoteServiceMappingGroupList.put(RemoteServiceUtil.NEO4J_GRAPH_INDEX_SERVICE, SERVICE_GROUP_NEO4J);
remoteServiceMappingGroupList.put(RemoteServiceUtil.NEO4J_GRAPH_PATH_SERVICE, SERVICE_GROUP_NEO4J);
remoteServiceMappingGroupList.put(RemoteServiceUtil.NEO4J_GRAPH_CYPHER_SERVICE, SERVICE_GROUP_NEO4J);
return remoteServiceMappingGroupL
3.1.4.2 RemoteLoginStatusUtil
package com.hnepri.neo4j.client.rmi.
import java.util.HashM
* Description: 远程登录状态工具类&br&
* Copyright: Copyright (c) 2015&br&
* Company: 河南电力科学研究院智能电网所&br&
* @author shangbingbing 编写
* @version 1.0
public class RemoteLoginStatusUtil {
* 登录状态值：登录成功0
public static final int LOGIN_STATUS_SUCCESS = 0;
* 登录状态值：用户或密码为空1
public static final int LOGIN_STATUS_USER_PASSWORD_EMPTY = 1;
* 登录状态值：用户不存在2
public static final int LOGIN_STATUS_USER_ERROR = 2;
* 登录状态值：密码错误3
public static final int LOGIN_STATUS_PASSWORD_ERROR = 3;
* 登录状态值：用户无访问权限4
public static final int LOGIN_STATUS_USER_PERMISSION_ERROR = 4;
* 登录状态值：IP无访问权限5
public static final int LOGIN_STATUS_IP_PERMISSION_ERROR = 5;
private static HashMap&Integer,String& remoteLoginStatusList = null;
public static HashMap&Integer,String& getRemoteLoginStatusList() {
if(remoteLoginStatusList == null) {
remoteLoginStatusList = new HashMap&Integer,String&();
remoteLoginStatusList.put(LOGIN_STATUS_SUCCESS, "登录验证通过");
remoteLoginStatusList.put(LOGIN_STATUS_USER_PASSWORD_EMPTY, "用户或者密码为空");
remoteLoginStatusList.put(LOGIN_STATUS_USER_ERROR, "用户不存在");
remoteLoginStatusList.put(LOGIN_STATUS_PASSWORD_ERROR, "用户密码错误");
remoteLoginStatusList.put(LOGIN_STATUS_USER_PERMISSION_ERROR, "用户无访问权限");
remoteLoginStatusList.put(LOGIN_STATUS_IP_PERMISSION_ERROR, "IP地址无访问权限");
return remoteLoginStatusL
3.1.4.3 RemoteServiceUtil
package com.hnepri.neo4j.client.rmi.
import java.util.HashM
* Description: 远程服务工具类&br&
* Copyright: Copyright (c) 2015&br&
* Company: 河南电力科学研究院智能电网所&br&
* @author shangbingbing 编写
* @version 1.0
public class RemoteServiceUtil {
* Neo4j图数据库信息管理服务
public static final String NEO4J_GRAPH_MANAGE_SERVICE = "neo4j-graph-manage-service";
* Neo4j图数据库Node节点服务
public static final String NEO4J_GRAPH_NODE_SERVICE = "neo4j-graph-node-service";
* Neo4j图数据库Index索引服务
public static final String NEO4J_GRAPH_INDEX_SERVICE = "neo4j-graph-index-service";
* Neo4j图数据库Path路径服务
public static final String NEO4J_GRAPH_PATH_SERVICE = "neo4j-graph-path-service";
* Neo4j图数据库Cypher查询服务
public static final String NEO4J_GRAPH_CYPHER_SERVICE = "neo4j-graph-cypher-service";
private static HashMap&String,String& remoteServiceList = null;
public static HashMap&String,String& getRemoteServiceList() {
if(remoteServiceList == null) {
remoteServiceList = new HashMap&String,String&();
remoteServiceList.put(NEO4J_GRAPH_MANAGE_SERVICE, "Neo4j图数据库信息管理服务");
remoteServiceList.put(NEO4J_GRAPH_NODE_SERVICE, "Neo4j图数据库Node节点服务");
remoteServiceList.put(NEO4J_GRAPH_INDEX_SERVICE, "Neo4j图数据库Index索引服务");
remoteServiceList.put(NEO4J_GRAPH_PATH_SERVICE, "Neo4j图数据库Path路径服务");
remoteServiceList.put(NEO4J_GRAPH_CYPHER_SERVICE, "Neo4j图数据库Cypher查询服务");
return remoteServiceL}