import org.spongepowered.api.data.manipulator.mutable.item.DurabilityData; //导入依赖的package包/类
@Override
public CommandResult execute(CommandSource sender, CommandContext args) throws CommandException {
    checkIfPlayer(sender);
    checkPermission(sender, ItemPermissions.UC_ITEM_ITEMDURABILITY_BASE);
    Player p = (Player) sender;

    if (!p.getItemInHand(HandTypes.MAIN_HAND).isPresent() || p.getItemInHand(HandTypes.MAIN_HAND).get().getItem().equals(ItemTypes.NONE)) {
        throw new ErrorMessageException(Messages.getFormatted(p, "item.noiteminhand"));
    }
    ItemStack stack = p.getItemInHand(HandTypes.MAIN_HAND).get();
    int durability = args.<Integer>getOne("durability").get();

    if (!stack.supports(DurabilityData.class)) {
        throw new ErrorMessageException(Messages.getFormatted(sender, "item.command.itemdurability.notsupported"));
    }

    if (durability < stack.get(DurabilityData.class).get().durability().getMinValue() || durability > stack.get(DurabilityData.class).get().durability().getMaxValue()) {
        throw new ErrorMessageException(Messages.getFormatted(sender, "item.numberinvalid", "%number%", durability));
    }

    stack.offer(Keys.ITEM_DURABILITY, durability);
    p.setItemInHand(HandTypes.MAIN_HAND, stack);
    Messages.send(sender, "item.command.itemdurability.success", "%arg%", durability);
    return CommandResult.success();
}
 

import org.spongepowered.api.data.manipulator.mutable.item.DurabilityData; //导入依赖的package包/类
/**
 * Converts a given {@link DataManipulator} value to a raw damage value.
 *
 * @param data The {@link DataManipulator} value to convert
 * @return The raw damage value corresponding to {@code data}, or
 * {@code 0} if one cannot be obtained.
 */
public static int getDamageValue(DataManipulator<?, ?> data) {
    if (data instanceof VariantData) {
        return getDamageValueFromEnum((VariantData) data);
    } else if (data instanceof DurabilityData) {
        return ((DurabilityData) data).durability().get();
    }
    return 0;
}
 

import org.spongepowered.api.data.manipulator.mutable.item.DurabilityData; //导入依赖的package包/类
/**
 * Obtains {@link DataManipulator} from an ItemStack.
 * @param item The ItemStack to retrieve {@link DataManipulator} from
 * @return The obtained {@link DataManipulator}, or {@code null} if none can
 *         be discerned
 */
@SuppressWarnings("rawtypes") // I tried parameterizing the return value but Java absolutely spazzed out about it
public static DataManipulator getItemData(ItemStack item) {
    switch (item.getType()) {
        case COAL:
            return getItemData(item, COAL_ITEM_DATA, COAL_MAP);
        case COOKED_FISH:
            return getItemData(item, COOKED_FISH_ITEM_DATA, COOKED_FISH_MAP);
        case WOOL:
            break;
        case INK_SACK:
            break;
        case STAINED_CLAY:
            break;
        case STAINED_GLASS:
            break;
        case STAINED_GLASS_PANE:
            return getItemData(item, DYEABLE_DATA, DYE_MAP);
        case RAW_FISH:
            return getItemData(item, FISH_DATA, FISH_MAP);
        case GOLDEN_APPLE:
            return getItemData(item, GOLDEN_APPLE_ITEM_DATA, GOLDEN_APPLE_MAP);
        default:
            Optional<DurabilityData> data =
                    org.spongepowered.api.item.inventory.ItemStack.builder()
                            .itemType(MaterialConverter.asItem(item.getType()))
                            .quantity(1).build().get(DURABILITY_DATA);
            if (data.isPresent()) {
                return data.get();
            } else {
                throw new UnsupportedOperationException();
            }
    }
    return null;
}
 

import org.spongepowered.api.data.manipulator.mutable.item.DurabilityData; //导入依赖的package包/类
public DurabilityDataView(DurabilityData value) {
    super(value);

    this.unbreakable = value.unbreakable().get();
    this.durability = value.durability().get();
}
 

import org.spongepowered.api.data.manipulator.mutable.item.DurabilityData; //导入依赖的package包/类
public CommandResult execute(CommandSource src, CommandContext ctx) throws CommandException
{
	if (src instanceof Player)
	{
		Player player = (Player) src;

		if (player.getItemInHand(HandTypes.MAIN_HAND).isPresent())
		{
			ItemStack stack = player.getItemInHand(HandTypes.MAIN_HAND).get();

			if (stack.get(DurabilityData.class).isPresent())
			{
				DurabilityData durabilityData = stack.get(DurabilityData.class).get();
				DataTransactionResult transactionResult = stack.offer(Keys.ITEM_DURABILITY, durabilityData.durability().getMaxValue());

				if (transactionResult.isSuccessful())
				{
					player.setItemInHand(HandTypes.MAIN_HAND, stack);
					src.sendMessage(Text.of(TextColors.GREEN, "Success! ", TextColors.YELLOW, "Repaired item in hand."));
				}
				else
				{
					src.sendMessage(Text.of(TextColors.DARK_RED, "Error! ", TextColors.RED, "Failed to repair item."));
				}
			}
			else
			{
				src.sendMessage(Text.of(TextColors.DARK_RED, "Error! ", TextColors.RED, "The item you're holding is not reparable."));
			}
		}
		else
		{
			src.sendMessage(Text.of(TextColors.DARK_RED, "Error! ", TextColors.RED, "You must be holding something to repair!"));
		}
	}
	else
	{
		src.sendMessage(Text.of(TextColors.DARK_RED, "Error! ", TextColors.RED, "Must be an in-game player to use /repair!"));
	}

	return CommandResult.success();
}