Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Konversi atribut kontrol
<a name="ddb-en-client-adv-features-conversion"></a>

Secara default, skema tabel menyediakan konverter untuk banyak jenis Java umum melalui implementasi default antarmuka. `[AttributeConverterProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/AttributeConverterProvider.html)` Anda dapat mengubah keseluruhan perilaku default dengan `AttributeConverterProvider` implementasi kustom. Anda juga dapat mengubah konverter untuk satu atribut.

Untuk daftar konverter yang tersedia, lihat [AttributeConverter](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/AttributeConverter.html)antarmuka Java doc.

## Menyediakan penyedia konverter atribut khusus
<a name="ddb-en-client-adv-features-conversion-prov"></a>

Anda dapat memberikan satu `AttributeConverterProvider` atau satu rantai `AttributeConverterProvider` s yang dipesan melalui `@DynamoDbBean` `(converterProviders = {…})` anotasi. Setiap kustom `AttributeConverterProvider` harus memperluas `AttributeConverterProvider` antarmuka.

Perhatikan bahwa jika Anda menyediakan rantai penyedia konverter atribut Anda sendiri, Anda akan mengganti penyedia konverter default,`DefaultAttributeConverterProvider`. Jika Anda ingin menggunakan fungsionalitas`DefaultAttributeConverterProvider`, Anda harus memasukkannya ke dalam rantai. 

Dimungkinkan juga untuk membubuhi keterangan kacang dengan array kosong. `{}` Ini menonaktifkan penggunaan penyedia konverter atribut apa pun, termasuk default. Dalam hal ini semua atribut yang akan dipetakan harus memiliki konverter atribut mereka sendiri.

Cuplikan berikut menunjukkan penyedia konverter tunggal.

```
@DynamoDbBean(converterProviders = ConverterProvider1.class)
public class Customer {

}
```

Cuplikan berikut menunjukkan penggunaan rantai penyedia konverter. Karena default SDK disediakan terakhir, ia memiliki prioritas terendah.

```
@DynamoDbBean(converterProviders = {
   ConverterProvider1.class, 
   ConverterProvider2.class,
   DefaultAttributeConverterProvider.class})
public class Customer {

}
```

Pembangun skema tabel statis memiliki `attributeConverterProviders()` metode yang bekerja dengan cara yang sama. Ini ditunjukkan dalam cuplikan berikut.

```
private static final StaticTableSchema<Customer> CUSTOMER_TABLE_SCHEMA =
  StaticTableSchema.builder(Customer.class)
    .newItemSupplier(Customer::new)
    .addAttribute(String.class, a -> a.name("name")
                                     a.getter(Customer::getName)
                                     a.setter(Customer::setName))
    .attributeConverterProviders(converterProvider1, converterProvider2)
    .build();
```

## Ganti pemetaan atribut tunggal
<a name="ddb-en-client-adv-features-conversion-single"></a>

Untuk mengganti cara atribut tunggal dipetakan, berikan atribut `AttributeConverter` untuk atribut. Penambahan ini mengesampingkan konverter apa pun yang disediakan oleh skema `AttributeConverterProviders` tabel. Ini menambahkan konverter khusus hanya untuk atribut itu. Atribut lain, bahkan yang dari tipe yang sama, tidak akan menggunakan konverter itu kecuali jika secara eksplisit ditentukan untuk atribut lainnya.

`@DynamoDbConvertedBy`Anotasi ini digunakan untuk menentukan `AttributeConverter` kelas kustom seperti yang ditunjukkan dalam cuplikan berikut.

```
@DynamoDbBean
public class Customer {
    private String name;

    @DynamoDbConvertedBy(CustomAttributeConverter.class)
    public String getName() { return this.name; }
    public void setName(String name) { this.name = name;}
}
```

Pembangun untuk skema statis memiliki `attributeConverter()` metode pembangun atribut yang setara. Metode ini mengambil contoh dari `AttributeConverter` sebagai berikut menunjukkan.

```
private static final StaticTableSchema<Customer> CUSTOMER_TABLE_SCHEMA =
  StaticTableSchema.builder(Customer.class)
    .newItemSupplier(Customer::new)
    .addAttribute(String.class, a -> a.name("name")
                                     a.getter(Customer::getName)
                                     a.setter(Customer::setName)
                                     a.attributeConverter(customAttributeConverter))
    .build();
```

## Contoh
<a name="ddb-en-client-adv-features-conversion-example"></a>

Contoh ini menunjukkan `AttributeConverterProvider` implementasi yang menyediakan konverter atribut untuk [https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/net/HttpCookie.html](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/net/HttpCookie.html)objek. 

`SimpleUser`Kelas berikut berisi atribut bernama `lastUsedCookie` yang merupakan instance dari`HttpCookie`.

Parameter untuk `@DynamoDbBean` anotasi mencantumkan dua `AttributeConverterProvider` kelas yang menyediakan konverter.

------
#### [ Class with annotations ]

```
    @DynamoDbBean(converterProviders = {CookieConverterProvider.class, DefaultAttributeConverterProvider.class})
    public static final class SimpleUser {
        private String name;
        private HttpCookie lastUsedCookie;

        @DynamoDbPartitionKey
        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public HttpCookie getLastUsedCookie() {
            return lastUsedCookie;
        }

        public void setLastUsedCookie(HttpCookie lastUsedCookie) {
            this.lastUsedCookie = lastUsedCookie;
        }
```

------
#### [ Static table schema ]

```
    private static final TableSchema<SimpleUser> SIMPLE_USER_TABLE_SCHEMA =
            TableSchema.builder(SimpleUser.class)
                    .newItemSupplier(SimpleUser::new)
                    .attributeConverterProviders(CookieConverterProvider.create(), AttributeConverterProvider.defaultProvider())
                    .addAttribute(String.class, a -> a.name("name")
                            .setter(SimpleUser::setName)
                            .getter(SimpleUser::getName)
                            .tags(StaticAttributeTags.primaryPartitionKey()))
                    .addAttribute(HttpCookie.class, a -> a.name("lastUsedCookie")
                            .setter(SimpleUser::setLastUsedCookie)
                            .getter(SimpleUser::getLastUsedCookie))
                    .build();
```

------

`CookieConverterProvider`Dalam contoh berikut memberikan contoh dari sebuah`HttpCookeConverter`.

```
    public static final class CookieConverterProvider implements AttributeConverterProvider {
        private final Map<EnhancedType<?>, AttributeConverter<?>> converterCache = ImmutableMap.of(
                // 1. Add HttpCookieConverter to the internal cache.
                EnhancedType.of(HttpCookie.class), new HttpCookieConverter());

        public static CookieConverterProvider create() {
            return new CookieConverterProvider();
        }

        // The SDK calls this method to find out if the provider contains a AttributeConverter instance
        // for the EnhancedType<T> argument.
        @SuppressWarnings("unchecked")
        @Override
        public <T> AttributeConverter<T> converterFor(EnhancedType<T> enhancedType) {
            return (AttributeConverter<T>) converterCache.get(enhancedType);
        }
    }
```

### Kode konversi
<a name="ddb-en-client-adv-features-conversion-example-code"></a>

Dalam `transformFrom()` metode `HttpCookieConverter` kelas berikut, kode menerima `HttpCookie` instance dan mengubahnya menjadi peta DynamoDB yang disimpan sebagai atribut.

`transformTo()`Metode menerima parameter peta DynamoDB, kemudian memanggil konstruktor `HttpCookie` yang membutuhkan nama dan nilai.

```
    public static final class HttpCookieConverter implements AttributeConverter<HttpCookie> {

        @Override
        public AttributeValue transformFrom(HttpCookie httpCookie) {

            return AttributeValue.fromM(
            Map.of ("cookieName", AttributeValue.fromS(httpCookie.getName()),
                    "cookieValue", AttributeValue.fromS(httpCookie.getValue()))
            );
        }

        @Override
        public HttpCookie transformTo(AttributeValue attributeValue) {
            Map<String, AttributeValue> map = attributeValue.m();
            return new HttpCookie(
                    map.get("cookieName").s(),
                    map.get("cookieValue").s());
        }

        @Override
        public EnhancedType<HttpCookie> type() {
            return EnhancedType.of(HttpCookie.class);
        }

        @Override
        public AttributeValueType attributeValueType() {
            return AttributeValueType.M;
        }
    }
```