java.lang.Object
- javax.management.NotificationBroadcasterSupport
- - javax.management.relation.RelationService

实现的所有接口

EventListener ， MBeanRegistration ， NotificationBroadcaster ， NotificationEmitter ， NotificationListener ， RelationServiceMBean
```
public class RelationService
extends NotificationBroadcasterSupport
implements RelationServiceMBean, MBeanRegistration, NotificationListener
```
Relation Service负责创建和删除关系类型和关系，处理一致性和提供查询机制。
它通过扩展NotificationBroadcasterSupport来实现NotificationBroadcaster，以便在从中删除关系时发送通知。

它实现了NotificationListener接口，以便能够接收有关在关系角色和关系MBean中引用的MBean注销的通知。

它实现了MBeanRegistration接口，以便能够检索其ObjectName和MBean Server。

从以下版本开始：

1.5

构造方法摘要

构造方法
构造器	描述
`RelationService(boolean immediatePurgeFlag)`	构造函数。

方法摘要

所有方法实例方法具体的方法
变量和类型	方法	描述
`void`	`addRelation(ObjectName relationObjectName)`	添加用户创建的MBean（并由他在MBean Server中注册）作为Relation Service中的关系。
`void`	`addRelationType(RelationType relationTypeObj)`	将给定对象添加为关系类型。
`Integer`	`checkRoleReading(String roleName, String relationTypeName)`	检查是否可以在给定类型的关系中读取给定的角色。
`Integer`	`checkRoleWriting(Role role, String relationTypeName, Boolean initFlag)`	检查是否可以在给定类型的关系中设置给定角色。
`void`	`createRelation(String relationId, String relationTypeName, RoleList roleList)`	创建给定关系类型的简单关系（由RelationSupport对象表示），并将其添加到Relation Service中。
`void`	`createRelationType(String relationTypeName, RoleInfo[] roleInfoArray)`	使用给定的角色信息（由RoleInfo对象提供）创建关系类型（RelationTypeSupport对象），并将其添加到Relation Service中。
`Map<ObjectName,List<String>>`	`findAssociatedMBeans(ObjectName mbeanName, String relationTypeName, String roleName)`	检索与关系中给定的MBean关联的MBean。
`Map<String,List<String>>`	`findReferencingRelations(ObjectName mbeanName, String relationTypeName, String roleName)`	检索引用给定MBean的关系。
`List<String>`	`findRelationsOfType(String relationTypeName)`	返回给定类型的关系的关系id。
`List<String>`	`getAllRelationIds()`	返回Relation Service处理的所有关系的所有关系id。
`List<String>`	`getAllRelationTypeNames()`	检索所有已知关系类型的名称。
`RoleResult`	`getAllRoles(String relationId)`	返回关系中存在的所有角色。
`MBeanNotificationInfo[]`	`getNotificationInfo()`	返回NotificationInfo对象，该对象包含通知的Java类的名称和发送的通知类型。
`boolean`	`getPurgeFlag()`	返回标志以指示何时收到关于在关系中引用的MBean的注销的通知，是否必须立即“清除”关系（查找关系不再有效），或者是否将执行仅在显式调用purgeRelations方法时执行。
`Map<ObjectName,List<String>>`	`getReferencedMBeans(String relationId)`	检索在关系的各种角色中引用的MBean。
`String`	`getRelationTypeName(String relationId)`	返回给定关系的关联关系类型的名称。
`List<ObjectName>`	`getRole(String relationId, String roleName)`	检索给定关系中给定角色名称的角色值。
`Integer`	`getRoleCardinality(String relationId, String roleName)`	检索给定角色中当前引用的MBean数。
`RoleInfo`	`getRoleInfo(String relationTypeName, String roleInfoName)`	检索给定关系类型的给定角色名称的角色信息。
`List<RoleInfo>`	`getRoleInfos(String relationTypeName)`	检索给定关系类型的角色信息（RoleInfo对象）列表。
`RoleResult`	`getRoles(String relationId, String[] roleNameArray)`	检索给定关系中给定名称的角色值。
`void`	`handleNotification(Notification notif, Object handback)`	发生JMX通知时调用。
`Boolean`	`hasRelation(String relationId)`	检查Relation Service中是否存在使用给定关系id标识的关系。
`void`	`isActive()`	检查Relation Service是否处于活动状态。
`String`	`isRelation(ObjectName objectName)`	如果MBean已作为Relation Service中的关系添加，则返回与给定ObjectName关联的关系id。
`ObjectName`	`isRelationMBean(String relationId)`	如果关系由MBean表示（由用户创建并作为Relation Service中的关系添加），则返回MBean的ObjectName。
`void`	`purgeRelations()`	清除关系。
`void`	`removeRelation(String relationId)`	从Relation Service中删除给定的关系。
`void`	`removeRelationType(String relationTypeName)`	从Relation Service中删除给定的关系类型。
`void`	`sendRelationCreationNotification(String relationId)`	发送关系创建的通知（RelationNotification）。
`void`	`sendRelationRemovalNotification(String relationId, List<ObjectName> unregMBeanList)`	发送关系删除通知（RelationNotification）。
`void`	`sendRoleUpdateNotification(String relationId, Role newRole, List<ObjectName> oldValue)`	为给定关系中的角色更新发送通知（RelationNotification）。
`void`	`setPurgeFlag(boolean purgeFlag)`	设置标志以指示何时收到关于在关系中引用的MBean的注销的通知，是否必须立即“清除”关系（查找关系不再有效），或者是否将执行仅在显式调用purgeRelations方法时执行。
`void`	`setRole(String relationId, Role role)`	在给定关系中设置给定角色。
`RoleResult`	`setRoles(String relationId, RoleList roleList)`	在给定关系中设置给定角色。
`void`	`updateRoleMap(String relationId, Role newRole, List<ObjectName> oldValue)`	处理给定关系中给定角色更新的Relation Service角色映射的更新。

声明方法的类 javax.management.NotificationBroadcasterSupport
addNotificationListener, handleNotification, sendNotification

声明方法的类 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

声明方法的接口 javax.management.MBeanRegistration
postDeregister, postRegister, preDeregister, preRegister

声明方法的接口 javax.management.NotificationBroadcaster
removeNotificationListener

声明方法的接口 javax.management.NotificationEmitter
removeNotificationListener

- 构造方法详细信息
  - RelationService
```
public RelationService(boolean immediatePurgeFlag)
```
    构造函数。
    
    参数
    
    immediatePurgeFlag - 用于指示何时收到关于在关系中引用的MBean的注销的通知的标志，如果必须立即执行“清除”关系（查找关系不再有效），或者是否将执行仅当显式调用purgeRelations方法时。
    真的是立即清除。
- 方法详细信息
  - isActive
```
public void isActive()
              throws RelationServiceNotRegisteredException
```
    检查Relation Service是否处于活动状态。当前条件是必须在MBean Server中注册Relation Service
    
    Specified by:
    
    isActive ，接口 RelationServiceMBean
    
    异常
    
    RelationServiceNotRegisteredException - 如果没有注册
  - getPurgeFlag
```
public boolean getPurgeFlag()
```
    返回标志以指示何时收到关于在关系中引用的MBean的注销的通知，是否必须立即“清除”关系（查找关系不再有效），或者是否将执行仅在显式调用purgeRelations方法时执行。
    真的是立即清除。
    
    Specified by:
    
    getPurgeFlag ，界面 RelationServiceMBean
    
    结果
    
    如果清除是自动的，则为true。
    
    另请参见：
    
    setPurgeFlag(boolean)
  - setPurgeFlag
```
public void setPurgeFlag(boolean purgeFlag)
```
    设置标志以指示何时收到关于在关系中引用的MBean的注销的通知，是否必须立即“清除”关系（查找关系不再有效），或者是否将执行仅在显式调用purgeRelations方法时执行。
    真的是立即清除。
    
    Specified by:
    
    setPurgeFlag ，接口 RelationServiceMBean
    
    参数
    
    purgeFlag - 国旗
    
    另请参见：
    
    getPurgeFlag()
  - createRelationType
```
public void createRelationType(String relationTypeName,
                               RoleInfo[] roleInfoArray)
                        throws IllegalArgumentException,
                               InvalidRelationTypeException
```
    使用给定的角色信息（由RoleInfo对象提供）创建关系类型（RelationTypeSupport对象），并将其添加到Relation Service中。
    
    Specified by:
    
    createRelationType ，界面 RelationServiceMBean
    
    参数
    
    relationTypeName - 关系类型的名称
    
    roleInfoArray - 角色信息数组
    
    异常
    
    IllegalArgumentException - 如果为null参数
    
    InvalidRelationTypeException - 如果：
    - 已经存在具有该名称的关系类型
    
    - 两个不同的角色信息使用相同的名称
    
    - 没有提供角色信息
    
    - 提供一个空角色信息
  - addRelationType
```
public void addRelationType(RelationType relationTypeObj)
                     throws IllegalArgumentException,
                            InvalidRelationTypeException
```
    将给定对象添加为关系类型。该对象应该实现RelationType接口。
    
    Specified by:
    
    addRelationType ，接口 RelationServiceMBean
    
    参数
    
    relationTypeObj - 关系类型对象（实现RelationType接口）
    
    异常
    
    IllegalArgumentException - 如果为null参数或 relationTypeObj.getRelationTypeName()返回null。
    
    InvalidRelationTypeException - 如果：
    - 同名已用于两个不同的角色
    
    - 没有提供角色信息
    
    - 提供一个空角色信息
    
    - 已经存在具有该名称的关系类型
  - getAllRelationTypeNames
```
public List<String> getAllRelationTypeNames()
```
    检索所有已知关系类型的名称。
    
    Specified by:
    
    getAllRelationTypeNames ，界面 RelationServiceMBean
    
    结果
    
    关系类型名称的ArrayList（字符串）
  - getRoleInfos
```
public List<RoleInfo> getRoleInfos(String relationTypeName)
                            throws IllegalArgumentException,
                                   RelationTypeNotFoundException
```
    检索给定关系类型的角色信息（RoleInfo对象）列表。
    
    Specified by:
    
    getRoleInfos ，界面 RelationServiceMBean
    
    参数
    
    relationTypeName - 关系类型的名称
    
    结果
    
    RoleInfo的ArrayList。
    
    异常
    
    IllegalArgumentException - 如果为null参数
    
    RelationTypeNotFoundException - 如果没有与该名称的关系类型。
  - getRoleInfo
```
public RoleInfo getRoleInfo(String relationTypeName,
                            String roleInfoName)
                     throws IllegalArgumentException,
                            RelationTypeNotFoundException,
                            RoleInfoNotFoundException
```
    检索给定关系类型的给定角色名称的角色信息。
    
    Specified by:
    
    getRoleInfo在接口 RelationServiceMBean
    
    参数
    
    relationTypeName - 关系类型的名称
    
    roleInfoName - 角色名称
    
    结果
    
    RoleInfo对象。
    
    异常
    
    IllegalArgumentException - 如果为null参数
    
    RelationTypeNotFoundException - 如果在Relation Service中未知关系类型
    
    RoleInfoNotFoundException - 如果角色不是关系类型的一部分。
  - removeRelationType
```
public void removeRelationType(String relationTypeName)
                        throws RelationServiceNotRegisteredException,
                               IllegalArgumentException,
                               RelationTypeNotFoundException
```
    从Relation Service中删除给定的关系类型。
    将从Relation Service中删除该类型的关系对象。
    
    Specified by:
    
    removeRelationType ，接口 RelationServiceMBean
    
    参数
    
    relationTypeName - 要删除的关系类型的名称
    
    异常
    
    RelationServiceNotRegisteredException - 如果未在MBean Server中注册Relation Service
    
    IllegalArgumentException - 如果为null参数
    
    RelationTypeNotFoundException - 如果没有与该名称的关系类型
  - createRelation
```
public void createRelation(String relationId,
                           String relationTypeName,
                           RoleList roleList)
                    throws RelationServiceNotRegisteredException,
                           IllegalArgumentException,
                           RoleNotFoundException,
                           InvalidRelationIdException,
                           RelationTypeNotFoundException,
                           InvalidRoleValueException
```
    创建给定关系类型的简单关系（由RelationSupport对象表示），并将其添加到Relation Service中。
    根据参数中提供的角色列表初始化角色。未以这种方式初始化的那些被设置为ObjectNames的空ArrayList。
    
    发送具有RELATION_BASIC_CREATION类型的RelationNotification。
    
    Specified by:
    
    createRelation在接口 RelationServiceMBean
    
    参数
    
    relationId - 关系标识符，用于唯一标识Relation Service内的关系
    
    relationTypeName - 关系类型的名称（必须在Relation Service中创建）
    
    roleList - 用于初始化关系角色的角色列表（可以为null）。
    
    异常
    
    RelationServiceNotRegisteredException - 如果未在MBean Server中注册Relation Service
    
    IllegalArgumentException - 如果为null参数，则角色列表除外，如果没有角色初始化，则可以为null
    
    RoleNotFoundException - 如果为关系类型中不存在的角色提供了值
    
    InvalidRelationIdException - 如果已使用关系ID
    
    RelationTypeNotFoundException - 如果Relation Service中未知关系类型
    
    InvalidRoleValueException - 如果：
    - 相同的角色名称用于两个不同的角色
    
    - 给定值中引用的MBean数小于预期的最小程度
    
    - 提供值中引用的MBean数超过预期的最大程度
    
    - 值中一个引用的MBean不是该角色所期望的MBean类的Object
    
    - 不存在为该角色提供的MBean
  - addRelation
```
public void addRelation(ObjectName relationObjectName)
                 throws IllegalArgumentException,
                        RelationServiceNotRegisteredException,
                        NoSuchMethodException,
                        InvalidRelationIdException,
                        InstanceNotFoundException,
                        InvalidRelationServiceException,
                        RelationTypeNotFoundException,
                        RoleNotFoundException,
                        InvalidRoleValueException
```
    添加用户创建的MBean（并由他在MBean Server中注册）作为Relation Service中的关系。
    要作为关系添加，MBean必须符合以下条件：
    
    - 实现Relation接口
    
    - 为RelationService ObjectName提供当前Relation Service的ObjectName
    
    - 在当前的Relation Service中有一个唯一且未使用的关系id
    
    - 为关系类型提供在Relation Service中创建的关系类型
    
    - 具有符合关系类型中提供的角色信息的角色。
    
    Specified by:
    
    addRelation ，界面 RelationServiceMBean
    
    参数
    
    relationObjectName - 要添加的关系MBean的ObjectName。
    
    异常
    
    IllegalArgumentException - 如果为null参数
    
    RelationServiceNotRegisteredException - 如果未在MBean Server中注册Relation Service
    
    NoSuchMethodException - 如果MBean未实现Relation接口
    
    InvalidRelationIdException - 如果：
    - MBean中没有关系标识符
    
    - 关系标识符已在Relation Service中使用
    
    InstanceNotFoundException - 如果尚未注册给定ObjectName的MBean
    
    InvalidRelationServiceException - 如果：
    - MBean中没有Relation Service名称
    
    - MBean中的Relation Service名称不是当前Relation Service的名称
    
    RelationTypeNotFoundException - 如果：
    - MBean中没有关系类型名称
    
    - MBean中的关系类型名称与在Relation Service中创建的关系类型不对应
    
    InvalidRoleValueException - 如果：
    - 角色中引用的MBean数量小于预期的最小度数
    
    - 角色中引用的MBean数超过预期的最大程度
    
    - 值中一个引用的MBean不是该角色所期望的MBean类的Object
    
    - 不存在为角色提供的MBean
    
    RoleNotFoundException - 如果为关系类型中不存在的角色提供了值
  - isRelationMBean
```
public ObjectName isRelationMBean(String relationId)
                           throws IllegalArgumentException,
                                  RelationNotFoundException
```
    如果关系由MBean表示（由用户创建并作为Relation Service中的关系添加），则返回MBean的ObjectName。
    
    Specified by:
    
    isRelationMBean ，界面 RelationServiceMBean
    
    参数
    
    relationId - 标识关系的关系id
    
    结果
    
    对应关系MBean的ObjectName，如果关系不是MBean，则返回null。
    
    异常
    
    IllegalArgumentException - 如果为null参数
    
    RelationNotFoundException - 没有与该ID相关联的关系
  - isRelation
```
public String isRelation(ObjectName objectName)
                  throws IllegalArgumentException
```
    如果MBean已作为Relation Service中的关系添加，则返回与给定ObjectName关联的关系id。
    
    Specified by:
    
    isRelation ，界面 RelationServiceMBean
    
    参数
    
    objectName - 假定关系的ObjectName
    
    结果
    
    relation id（String）或null（如果ObjectName不是Relation Service处理的关系）
    
    异常
    
    IllegalArgumentException - 如果为null参数
  - hasRelation
```
public Boolean hasRelation(String relationId)
                    throws IllegalArgumentException
```
    检查Relation Service中是否存在使用给定关系id标识的关系。
    
    Specified by:
    
    hasRelation接口 RelationServiceMBean
    
    参数
    
    relationId - 标识关系的关系id
    
    结果
    
    boolean：如果存在关系，则为true，否则为false
    
    异常
    
    IllegalArgumentException - 如果为null参数
  - getAllRelationIds
```
public List<String> getAllRelationIds()
```
    返回Relation Service处理的所有关系的所有关系id。
    
    Specified by:
    
    getAllRelationIds在接口 RelationServiceMBean
    
    结果
    
    String的ArrayList
  - checkRoleReading
```
public Integer checkRoleReading(String roleName,
                                String relationTypeName)
                         throws IllegalArgumentException,
                                RelationTypeNotFoundException
```
    检查是否可以在给定类型的关系中读取给定的角色。
    
    Specified by:
    
    checkRoleReading ，界面 RelationServiceMBean
    
    参数
    
    roleName - 要检查的角色的名称
    
    relationTypeName - 关系类型的名称
    
    结果
    
    整数包装一个整数，对应于RoleUnresolved中表示为常量的可能问题：
    - 如果可以读取角色，则为0
    
    - 与RoleStatus.NO_ROLE_WITH_NAME对应的整数
    
    - 与RoleStatus.ROLE_NOT_READABLE对应的整数
    
    异常
    
    IllegalArgumentException - 如果为null参数
    
    RelationTypeNotFoundException - 如果在Relation Service中未知关系类型
  - checkRoleWriting
```
public Integer checkRoleWriting(Role role,
                                String relationTypeName,
                                Boolean initFlag)
                         throws IllegalArgumentException,
                                RelationTypeNotFoundException
```
    检查是否可以在给定类型的关系中设置给定角色。
    
    Specified by:
    
    checkRoleWriting ，接口 RelationServiceMBean
    
    参数
    
    role - 要检查的角色
    
    relationTypeName - 关系类型的名称
    
    initFlag - 指定对角色初始化进行检查的标志，不应验证写访问。
    
    结果
    
    整数包装一个整数，对应于RoleUnresolved中表示为常量的可能问题：
    - 如果可以设置角色，则为0
    
    - 与RoleStatus.NO_ROLE_WITH_NAME对应的整数
    
    - RoleStatus.ROLE_NOT_WRITABLE的整数
    
    - RoleStatus.LESS_THAN_MIN_ROLE_DEGREE的整数
    
    - RoleStatus.MORE_THAN_MAX_ROLE_DEGREE的整数
    
    - RoleStatus.REF_MBEAN_OF_INCORRECT_CLASS的整数
    
    - RoleStatus.REF_MBEAN_NOT_REGISTERED的整数
    
    异常
    
    IllegalArgumentException - 如果为null参数
    
    RelationTypeNotFoundException - 如果未知关系类型
  - sendRelationCreationNotification
```
public void sendRelationCreationNotification(String relationId)
                                      throws IllegalArgumentException,
                                             RelationNotFoundException
```
    发送关系创建的通知（RelationNotification）。通知类型是：
    - RelationNotification.RELATION_BASIC_CREATION，如果关系是Relation Service内部的对象
    
    - RelationNotification.RELATION_MBEAN_CREATION，如果关系是作为关系添加的MBean。
    
    源对象是Relation Service本身。
    
    它在Relation Service createRelation（）和addRelation（）方法中调用。
    
    Specified by:
    
    sendRelationCreationNotification ，接口 RelationServiceMBean
    
    参数
    
    relationId - 更新关系的关系标识符
    
    异常
    
    IllegalArgumentException - 如果为null参数
    
    RelationNotFoundException - 如果给定的关系id没有关系
  - sendRoleUpdateNotification
```
public void sendRoleUpdateNotification(String relationId,
                                       Role newRole,
                                       List<ObjectName> oldValue)
                                throws IllegalArgumentException,
                                       RelationNotFoundException
```
    为给定关系中的角色更新发送通知（RelationNotification）。通知类型是：
    - RelationNotification.RELATION_BASIC_UPDATE，如果关系是Relation Service内部的对象
    
    - RelationNotification.RELATION_MBEAN_UPDATE如果关系是作为关系添加的MBean。
    
    源对象是Relation Service本身。
    
    它在关系MBean setRole（）（对于给定角色）和setRoles（）（对于每个角色）方法（在RelationSupport类中提供的实现）中调用。
    
    它也在Relation Service setRole（）（用于给定角色）和setRoles（）（用于每个角色）方法中调用。
    
    Specified by:
    
    sendRoleUpdateNotification接口 RelationServiceMBean
    
    参数
    
    relationId - 更新关系的关系标识符
    
    newRole - 新角色（名称和新值）
    
    oldValue - 旧角色值（ObjectName对象列表）
    
    异常
    
    IllegalArgumentException - 如果为null参数
    
    RelationNotFoundException - 如果给定的关系id没有关系
  - sendRelationRemovalNotification
```
public void sendRelationRemovalNotification(String relationId,
                                            List<ObjectName> unregMBeanList)
                                     throws IllegalArgumentException,
                                            RelationNotFoundException
```
    发送关系删除通知（RelationNotification）。通知类型是：
    - RelationNotification.RELATION_BASIC_REMOVAL，如果关系是Relation Service内部的对象
    
    - RelationNotification.RELATION_MBEAN_REMOVAL，如果关系是作为关系添加的MBean。
    
    源对象是Relation Service本身。
    
    它在Relation Service removeRelation（）方法中调用。
    
    Specified by:
    
    sendRelationRemovalNotification ，界面 RelationServiceMBean
    
    参数
    
    relationId - 更新关系的关系标识符
    
    unregMBeanList - 由于关系删除而预期未注册的MBean的ObjectName列表（可以为null）
    
    异常
    
    IllegalArgumentException - 如果为null参数
    
    RelationNotFoundException - 如果给定的关系id没有关系
  - updateRoleMap
```
public void updateRoleMap(String relationId,
                          Role newRole,
                          List<ObjectName> oldValue)
                   throws IllegalArgumentException,
                          RelationServiceNotRegisteredException,
                          RelationNotFoundException
```
    处理给定关系中给定角色更新的Relation Service角色映射的更新。
    它在关系MBean setRole（）（对于给定角色）和setRoles（）（对于每个角色）方法（在RelationSupport类中提供的实现）中调用。
    
    它也在Relation Service setRole（）（用于给定角色）和setRoles（）（用于每个角色）方法中调用。
    
    要允许Relation Service维护一致性（在MBean取消注册的情况下）并且能够执行查询，必须在更新角色时调用此方法。
    
    Specified by:
    
    updateRoleMap ，界面 RelationServiceMBean
    
    参数
    
    relationId - 更新关系的关系标识符
    
    newRole - 新角色（名称和新值）
    
    oldValue - 旧角色值（ObjectName对象列表）
    
    异常
    
    IllegalArgumentException - 如果为null参数
    
    RelationServiceNotRegisteredException - 如果未在MBean Server中注册Relation Service
    
    RelationNotFoundException - 如果给定id没有关系。
  - removeRelation
```
public void removeRelation(String relationId)
                    throws RelationServiceNotRegisteredException,
                           IllegalArgumentException,
                           RelationNotFoundException
```
    从Relation Service中删除给定的关系。
    发送RelationNotification通知，其类型为：
    
    - 如果关系仅在Relation Service内部，则为RelationNotification.RELATION_BASIC_REMOVAL
    
    - 如果关系注册为MBean，则为RelationNotification.RELATION_MBEAN_REMOVAL。
    
    对于在这种关系中引用的MBean，什么都不会做，
    
    Specified by:
    
    removeRelation在接口 RelationServiceMBean
    
    参数
    
    relationId - 要删除的关系的关系id
    
    异常
    
    RelationServiceNotRegisteredException - 如果未在MBean Server中注册Relation Service
    
    IllegalArgumentException - 如果为null参数
    
    RelationNotFoundException - 如果没有对应于给定关系id的关系
  - purgeRelations
```
public void purgeRelations()
                    throws RelationServiceNotRegisteredException
```
    清除关系。
    根据purgeFlag值，当收到关于关系中引用的MBean的注销的通知时（如果该标志设置为true），或者不是（如果该标志设置为false），则自动调用此方法。
    
    在这种情况下，用户可以调用它来保持关系的一致性。要记住，如果MBean未注册且清除没有立即完成，如果ObjectName被重用并分配给关系中引用的另一个MBean，则手动调用此purgeRelations（）方法将导致麻烦，因为将ObjectName视为对应于未注册的MBean，没有看到新的MBean。
    
    该行为取决于引用未注册的MBean的角色的基数：
    
    - 如果在角色中删除一个MBean引用使其引用数小于最小程度，则必须删除该关系。
    
    - 如果删除MBean引用后的剩余引用数仍在基数范围内，请保持关系并更新它调用其handleMBeanUnregistration（）回调。
    
    Specified by:
    
    purgeRelations ，界面 RelationServiceMBean
    
    异常
    
    RelationServiceNotRegisteredException - 如果未在MBean Server中注册Relation Service。
  - findReferencingRelations
```
public Map<String,List<String>> findReferencingRelations(ObjectName mbeanName,
                                                               String relationTypeName,
                                                               String roleName)
                                                        throws IllegalArgumentException
```
    检索引用给定MBean的关系。
    这对应于CIM“References”和“ReferenceNames”操作。
    
    Specified by:
    
    findReferencingRelations ，接口 RelationServiceMBean
    
    参数
    
    mbeanName - MBean的ObjectName
    
    relationTypeName - 可以为null; 如果指定，则在搜索中仅考虑该类型的关系。否则考虑所有关系类型。
    
    roleName - 可以为null; 如果指定，则仅返回该角色中引用MBean的关系。其他所有角色都被考虑在内。
    
    结果
    
    一个HashMap，其中键是引用MBean的关系的关系id，对于每个键，值是一个角色名称的ArrayList（因为MBean可以在同一关系中的多个角色中引用）。
    
    异常
    
    IllegalArgumentException - 如果为null参数
  - findAssociatedMBeans
```
public Map<ObjectName,List<String>> findAssociatedMBeans(ObjectName mbeanName,
                                                               String relationTypeName,
                                                               String roleName)
                                                        throws IllegalArgumentException
```
    检索与关系中给定的MBean关联的MBean。
    这对应于CIM Associators和AssociatorNames操作。
    
    Specified by:
    
    findAssociatedMBeans ，界面 RelationServiceMBean
    
    参数
    
    mbeanName - MBean的ObjectName
    
    relationTypeName - 可以为null; 如果指定，则在搜索中仅考虑该类型的关系。否则考虑所有关系类型。
    
    roleName - 可以为null; 如果指定，则仅考虑在该角色中引用MBean的关系。其他所有角色都被考虑在内。
    
    结果
    
    一个HashMap，其中键是与给定MBean关联的MBean的ObjectNames，对于每个键，值是一个ArrayList，表示关键MBean与给定关键字关联的关系ID（因为它们可以关联）在几个不同的关系）。
    
    异常
    
    IllegalArgumentException - 如果为null参数
  - findRelationsOfType
```
public List<String> findRelationsOfType(String relationTypeName)
                                 throws IllegalArgumentException,
                                        RelationTypeNotFoundException
```
    返回给定类型的关系的关系id。
    
    Specified by:
    
    findRelationsOfType ，界面 RelationServiceMBean
    
    参数
    
    relationTypeName - 关系类型名称
    
    结果
    
    关系ids的ArrayList。
    
    异常
    
    IllegalArgumentException - 如果为null参数
    
    RelationTypeNotFoundException - 如果没有与该名称的关系类型。
  - getRole
```
public List<ObjectName> getRole(String relationId,
                                String roleName)
                         throws RelationServiceNotRegisteredException,
                                IllegalArgumentException,
                                RelationNotFoundException,
                                RoleNotFoundException
```
    检索给定关系中给定角色名称的角色值。
    
    Specified by:
    
    getRole在接口 RelationServiceMBean
    
    参数
    
    relationId - 关系id
    
    roleName - 角色名称
    
    结果
    
    ObjectName对象的ArrayList是角色值
    
    异常
    
    RelationServiceNotRegisteredException - 如果未注册Relation Service
    
    IllegalArgumentException - 如果为null参数
    
    RelationNotFoundException - 如果与给定的id没有关系
    
    RoleNotFoundException - 如果：
    - 给定名称没有任何作用
    
    要么
    
    - 角色不可读。
    
    另请参见：
    
    setRole(java.lang.String, javax.management.relation.Role)
  - getRoles
```
public RoleResult getRoles(String relationId,
                           String[] roleNameArray)
                    throws RelationServiceNotRegisteredException,
                           IllegalArgumentException,
                           RelationNotFoundException
```
    检索给定关系中给定名称的角色值。
    
    Specified by:
    
    getRoles ，界面 RelationServiceMBean
    
    参数
    
    relationId - 关系id
    
    roleNameArray - 要检索的角色名称数组
    
    结果
    
    RoleResult对象，包括RoleList（用于成功检索的角色）和RoleUnresolvedList（用于未检索的角色）。
    
    异常
    
    RelationServiceNotRegisteredException - 如果未在MBean Server中注册Relation Service
    
    IllegalArgumentException - 如果为null参数
    
    RelationNotFoundException - 如果与给定的id没有关系
    
    另请参见：
    
    setRoles(java.lang.String, javax.management.relation.RoleList)
  - getAllRoles
```
public RoleResult getAllRoles(String relationId)
                       throws IllegalArgumentException,
                              RelationNotFoundException,
                              RelationServiceNotRegisteredException
```
    返回关系中存在的所有角色。
    
    Specified by:
    
    getAllRoles ，界面 RelationServiceMBean
    
    参数
    
    relationId - 关系id
    
    结果
    
    RoleResult对象，包括RoleList（用于成功检索的角色）和RoleUnresolvedList（用于不可读的角色）。
    
    异常
    
    IllegalArgumentException - 如果为null参数
    
    RelationNotFoundException - 如果给定id没有关系
    
    RelationServiceNotRegisteredException - 如果未在MBean Server中注册Relation Service
  - getRoleCardinality
```
public Integer getRoleCardinality(String relationId,
                                  String roleName)
                           throws IllegalArgumentException,
                                  RelationNotFoundException,
                                  RoleNotFoundException
```
    检索给定角色中当前引用的MBean数。
    
    Specified by:
    
    getRoleCardinality in interface RelationServiceMBean
    
    参数
    
    relationId - 关系id
    
    roleName - 角色名称
    
    结果
    
    该角色中当前引用的MBean的数量
    
    异常
    
    IllegalArgumentException - 如果为null参数
    
    RelationNotFoundException - 如果与给定的id没有关系
    
    RoleNotFoundException - 如果没有给定名称的角色
  - setRole
```
public void setRole(String relationId,
                    Role role)
             throws RelationServiceNotRegisteredException,
                    IllegalArgumentException,
                    RelationNotFoundException,
                    RoleNotFoundException,
                    InvalidRoleValueException
```
    在给定关系中设置给定角色。
    将根据关系的关系类型中提供的相应角色定义来检查角色
    
    Relation Service将跟踪更改，以通过处理引用的MBean注销来保持关系的一致性。
    
    Specified by:
    
    setRole ，界面 RelationServiceMBean
    
    参数
    
    relationId - 关系ID
    
    role - 要设置的角色（名称和新值）
    
    异常
    
    RelationServiceNotRegisteredException - 如果未在MBean Server中注册Relation Service
    
    IllegalArgumentException - 如果为null参数
    
    RelationNotFoundException - 如果与给定的id没有关系
    
    RoleNotFoundException - 如果角色不存在或不可写
    
    InvalidRoleValueException - 如果为角色提供的值无效：
    - 给定值中引用的MBean数小于预期的最小程度
    
    要么
    
    - 提供值中引用的MBean数超过预期的最大程度
    
    要么
    
    - 值中一个引用的MBean不是该角色所期望的MBean类的Object
    
    要么
    
    - 不存在为该角色提供的MBean
    
    另请参见：
    
    getRole(java.lang.String, java.lang.String)
  - setRoles
```
public RoleResult setRoles(String relationId,
                           RoleList roleList)
                    throws RelationServiceNotRegisteredException,
                           IllegalArgumentException,
                           RelationNotFoundException
```
    在给定关系中设置给定角色。
    将根据关系的关系类型中提供的相应角色定义来检查角色
    
    Relation Service通过处理引用的MBean注销来跟踪更改以保持关系的一致性。
    
    Specified by:
    
    setRoles ，界面 RelationServiceMBean
    
    参数
    
    relationId - 关系id
    
    roleList - 要设置的角色列表
    
    结果
    
    RoleResult对象，包括RoleList（用于成功设置的角色）和RoleUnresolvedList（用于未设置的角色）。
    
    异常
    
    RelationServiceNotRegisteredException - 如果未在MBean Server中注册Relation Service
    
    IllegalArgumentException - 如果为null参数
    
    RelationNotFoundException - 如果与给定的id没有关系
    
    另请参见：
    
    getRoles(java.lang.String, java.lang.String[])
  - getReferencedMBeans
```
public Map<ObjectName,List<String>> getReferencedMBeans(String relationId)
                                                       throws IllegalArgumentException,
                                                              RelationNotFoundException
```
    检索在关系的各种角色中引用的MBean。
    
    Specified by:
    
    getReferencedMBeans ，界面 RelationServiceMBean
    
    参数
    
    relationId - 关系id
    
    结果
    
    一个HashMap映射：
    ObjectName - > String的StringList（角色名称）
    
    异常
    
    IllegalArgumentException - 如果为null参数
    
    RelationNotFoundException - 如果给定关系id没有关系
  - getRelationTypeName
```
public String getRelationTypeName(String relationId)
                           throws IllegalArgumentException,
                                  RelationNotFoundException
```
    返回给定关系的关联关系类型的名称。
    
    Specified by:
    
    getRelationTypeName ，界面 RelationServiceMBean
    
    参数
    
    relationId - 关系id
    
    结果
    
    关联关系类型的名称。
    
    异常
    
    IllegalArgumentException - 如果为null参数
    
    RelationNotFoundException - 如果给定关系id没有关系
  - handleNotification
```
public void handleNotification(Notification notif,
                               Object handback)
```
    发生JMX通知时调用。当前处理用于取消注册MBean的通知，可以在关系角色中引用，也可以是关系本身。
    
    Specified by:
    
    handleNotification ，界面 NotificationListener
    
    参数
    
    notif - 通知。
    
    handback - 一个不透明对象，它帮助侦听器关联有关MBean发射器的信息（可以为null）。
  - getNotificationInfo
```
public MBeanNotificationInfo[] getNotificationInfo()
```
    返回NotificationInfo对象，该对象包含通知的Java类的名称和发送的通知类型。
    
    Specified by:
    
    getNotificationInfo在接口 NotificationBroadcaster
    
    结果
    
    the array of possible notifications.

Class RelationService

构造方法摘要

方法摘要

声明方法的类 javax.management.NotificationBroadcasterSupport

声明方法的类 java.lang.Object

声明方法的接口 javax.management.MBeanRegistration

声明方法的接口 javax.management.NotificationBroadcaster

声明方法的接口 javax.management.NotificationEmitter

构造方法详细信息

RelationService

方法详细信息

isActive

getPurgeFlag

setPurgeFlag

createRelationType

addRelationType

getAllRelationTypeNames

getRoleInfos

getRoleInfo

removeRelationType

createRelation

addRelation

isRelationMBean

isRelation

hasRelation

getAllRelationIds

checkRoleReading

checkRoleWriting

sendRelationCreationNotification

sendRoleUpdateNotification

sendRelationRemovalNotification

updateRoleMap

removeRelation

purgeRelations

findReferencingRelations

findAssociatedMBeans

findRelationsOfType

getRole

getRoles

getAllRoles

getRoleCardinality

setRole

setRoles

getReferencedMBeans

getRelationTypeName

handleNotification

getNotificationInfo