Easy-Trans

http://easy-trans.fhs-opensource.cn/components/
Admin
Easy-Trans is a Java component that simplifies data translation and enrichment in applications,...
Tokens:16,129
Snippets:56
Trust Score:0
Update:1 year ago
Show doc for...
Tokens:
Raw
### Manual Translation Methods

Provides examples of manual translation methods available through the TransService. It includes `unTransMore` for batch translation and `unTransOne` for translating a single object.

```java
transService.unTransMore(list);
transService.unTransOne(pojo)
```

--------------------------------

### Dictionary Translation Failure

Provides a debugging guide for dictionary translation failures, involving breakpoints in `TransService`, `DictionaryTransService`, and `BothCacheService`, and checking `ref` attribute correctness.

```Java
// Debugging steps for dictionary translation:
// 1. Breakpoint in TransService.trans(): Check if manual translation or global translation is enabled.
// 2. Breakpoint in DictionaryTransService.transOne(): Verify the translation type.
// 3. Breakpoint in BothCacheService.get(): Check if dictionary data is available in local map or Redis.
// 4. Verify the 'ref' attribute in the @Trans annotation points to a valid POJO field.
```

--------------------------------

### Java Cascade Translation Example

Demonstrates how to use the @Trans annotation for cascading translations in Java. This example shows how to retrieve province names using a city ID by defining nested @Trans annotations with specified fields and references.

```Java
class Area{
int id;
String name;
@Trans(type=simple,target=City.class,fields={"cityName","provinceId"},refs={"cityName","provinceId"},sort=0)
int cityId;
String cityName;
@Trans(type=simple,target=Province.class,fields={"provinceName"},refs={"provinceName"},sort=1)
int provinceId;
String provinceName;
}
```

--------------------------------

### POJO Translation Annotations

Example of using Easy Trans annotations (`@Trans`) in a POJO to define translation types (DICTIONARY, SIMPLE, RPC, ENUM) and map fields.

```java
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
//实现TransPojo  接口，代表这个类需要被翻译或者被当作翻译的数据源
publicclassStudentimplementsTransPojo{
// 字典翻译 ref为非必填
@Trans(type= TransType.DICTIONARY,key="sex",ref="sexName")
privateInteger sex;
//这个字段可以不写，实现了TransPojo接口后有一个getTransMap方法，sexName可以让前端去transMap取
privateString sexName;
//SIMPLE 翻译，用于关联其他的表进行翻译    schoolName 为 School 的一个字段
@Trans(type= TransType.SIMPLE,target= School.class,fields="schoolName")
privateString schoolId;
//远程翻译，调用其他微服务的数据源进行翻译
@Trans(type= TransType.RPC,targetClassName="com.fhs.test.pojo.School",fields="schoolName",serviceName="easyTrans",alias="middle")
privateString middleSchoolId;
// 枚举翻译，返回文科还是理科给前端
@Trans(type=TransType.ENUM,key="desc")
privateStudentType studentType = StudentType.ARTS;
publicstaticenumStudentType{
        ARTS("文科"),
        SCIENCES("理科");
privateString desc;
StudentType(Stringdesc){
this.desc = desc;
}
}
}
```

--------------------------------

### SIMPLE: Automatic Table Join Translation (Multiple Fields)

Shows how to perform automatic table join translations using multiple fields for a unique key. This example queries the 't_user' table using both 'studentName' and 'studentAge' to find the 'userId'.

```java
privateString studentName;
privateString studentAge;
@UnTrans(type= UnTransType.SIMPLE,tableName="t_user",refs={"studentName","studentAge"},columns={"name","age"},uniqueColumn="user_id")
privateInteger userId;
```

--------------------------------

### AutoTrans Annotation and Data Provider Implementation

Demonstrates how to use the @AutoTrans annotation on a service class to provide custom translation data. The service must implement the AutoTransable interface, providing methods to fetch data based on IDs. This example shows a TeacherService that provides teacher names and ages.

```Java
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;

// Assuming AutoTransable and VO are defined elsewhere
// import com.easytrans.annotation.AutoTrans;
// import com.easytrans.service.AutoTransable;
// import com.easytrans.vo.VO;

// Placeholder for AutoTrans annotation and AutoTransable interface for compilation
@interface AutoTrans {
    String namespace();
    String[] fields();
    String defaultAlias() default "";
    boolean globalCache() default false;
    boolean isAccess() default false;
    int cacheSeconds() default 1;
    int maxCache() default 1000;
}

interface AutoTransable {
    List selectByIds(List ids);
    List select();
    VO selectById(Object primaryValue);
}

class Teacher {
    private String teacherId;
    private String name;
    private int age;

    public String getTeacherId() { return teacherId; }
    public void setTeacherId(String teacherId) { this.teacherId = teacherId; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
}

class VO {}

@Service
@AutoTrans(namespace="teacher",fields={"name","age"},
defaultAlias="teacher",globalCache=true,cacheSeconds=10,maxCache=100)
public class TeacherService implements AutoTransable {
    @Override
    public List selectByIds(List ids) {
        List list = new ArrayList();
        Teacher t = null;
        for(Object id : ids){
            t = new Teacher();
            t.setTeacherId(id.toString());
            t.setName("老师名字" + id);
            t.setAge(18);
            list.add(t);
        }
        System.out.println("teacher service的findByIds 进来了");
        return list;
    }

    @Override
    public List select() {
        // 一般用不到这个，后面版本添加默认实现。
        return new ArrayList<>();
    }

    @Override
    public VO selectById(Object primaryValue) {
        System.out.println("teacher service的selectById 进来了" + primaryValue);
        Teacher t = new Teacher();
        t.setTeacherId(primaryValue.toString());
        t.setName("老师名字" + primaryValue);
        t.setAge(18);
        return t;
    }
}
```

--------------------------------

### SIMPLE: Automatic Table Join Translation (Single Field)

Illustrates using the @UnTrans annotation with the SIMPLE type for automatic table joins. This example shows how to query a primary key (id) from the 'school' table based on a 'schoolName' field and assign it to 'schoolId'.

```java
privateString schoolName;
@UnTrans(type= UnTransType.SIMPLE,tableName="school",refs="schoolName",columns="school_name",uniqueColumn="id")
privateInteger schoolId;
```

--------------------------------

### Multiple RestTemplate Startup Failure

Provides a solution for startup failures when multiple RestTemplates are present. It suggests marking one as primary using the '@Primary' annotation.

```Java
// Solution: Mark the primary RestTemplate with @Primary.
@Configuration
public class RestTemplateConfig {
    @Bean
    @Primary
    public RestTemplate primaryRestTemplate() {
        return new RestTemplate();
    }

    @Bean
    public RestTemplate secondaryRestTemplate() {
        return new RestTemplate();
    }
}
```

--------------------------------

### Troubleshooting SimpleTransService Errors

To resolve SimpleTransService errors after introducing the starter, ensure you have imported the appropriate extension package corresponding to your ORM framework.

```Java
// After introducing the starter, import the extension package for your ORM framework.
// Example for MyBatis-Plus:
// import com.xxx.easytrans.plus.extension.MyBatisPlusExtension;
```

--------------------------------

### Microservice Configuration for Easy Trans

Configuration for microservices, including adding '/easyTrans/proxy/**' to the whitelist for RPC translation and implementing authentication for inter-service requests.

```java
A、白名单添加 /easyTrans/proxy/** 保证其不被拦截，RPC trans的时候easytrans会自动调用目标微服务的接口来获取数据。
B、应用之间的认证可以通过filter/interceptor实现，然后自定义RestTemplate 保证easytrans在请求用户服务的时候带上需要认证的参数
```

--------------------------------

### Initialize Dictionary Data

Demonstrates how to inject and use the `DictionaryTransService` to refresh dictionary caches. This is useful if your project has a dictionary table.

```java
@Autowired//注入字典翻译服务
privateDictionaryTransService dictionaryTransService;
//在某处将字典缓存刷新到翻译服务中，以下是demo
Map<String,String> transMap =newHashMap<>();
       transMap.put("0","男");
       transMap.put("1","女");
       dictionaryTransService.refreshCache("gender",transMap);
```

--------------------------------

### Maven Dependencies for Easy Trans

Includes the main starter and various ORM framework extensions for Easy Trans. Note the groupId change to 'org.dromara' for Spring Boot 3.x and later versions (3.1.1+).

```xml
<dependency>
<groupId>org.dromara</groupId>
<artifactId>easy-trans-spring-boot-starter</artifactId>
<version>2.3.1</version>
</dependency>
```

```xml
<dependency>
<groupId>org.dromara</groupId>
<artifactId>easy-trans-mybatis-plus-extend</artifactId>
<version>2.3.1</version>
</dependency>
```

```xml
<dependency>
<groupId>org.dromara</groupId>
<artifactId>easy-trans-jpa-extend</artifactId>
<version>2.3.1</version>
</dependency>
```

```xml
<dependency>
<groupId>org.dromara</groupId>
<artifactId>easy-trans-jpa-sb3-extend</artifactId>
<version>2.2.3</version>
</dependency>
```

```xml
<dependency>
<groupId>org.dromara</groupId>
<artifactId>easy-trans-beetl-sql-extend</artifactId>
<version>2.3.1</version>
</dependency>
```

```xml
<dependency>
<groupId>org.dromara</groupId>
<artifactId>easy-trans-tk-extend</artifactId>
<version>2.3.1</version>
</dependency>
```

```xml
<dependency>
<groupId>org.dromara</groupId>
<artifactId>easy-trans-mybatis-flex-extend</artifactId>
<version>2.3.1</version>
</dependency>
```

```xml
<dependency>
<groupId>org.dromara</groupId>
<artifactId>easy-trans-easy-query-extend</artifactId>
<version>2.3.1</version>
</dependency>
```

```xml
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
```

```xml
<dependency>
<groupId>org.dromara</groupId>
<artifactId>easy-trans-untrans-driver</artifactId>
<version>2.3.1</version>
</dependency>
```

--------------------------------

### Easy-Trans Configuration Options

This snippet lists various configuration properties for Easy-Trans, controlling features like tiling, automatic map translation, dictionary caching, global response interception, RPC translation scope, and Mybatis-plus version compatibility.

```properties
easy-trans.is-enable-tile:true
easy-trans.is-enable-map-result
easy-trans.dict-use-redis
easy-trans.is-enable-global
easy-trans.is-enable-redis
easy-trans.db-type
easy-trans.is-enable-custom-rpc
easy-trans.mp-new
easy-trans.is-enable-cloud
```

--------------------------------

### Enable Multi-Database Support in Configuration

Enable the multi-database feature by setting the `easy-trans.multiple-data-sources` property to `true` in your application configuration file.

```properties
easy-trans.multiple-data-sources=true
```

--------------------------------

### Initialize Dictionary Cache

Demonstrates how to initialize the dictionary cache for Easy-Trans. This involves providing a map of key-value pairs representing dictionary entries. For microservice mode, Redis configuration is required. It also shows how to refresh the cache and notify other services.

```java
@Autowired
private DictionaryTransService dictionaryTransService;
//微服务模式下需要用到redis  请设置  easy-trans.dict-use-redis:true 和  easy-trans.is-enable-redis:true
Map<String,String> transMap =newHashMap<>();
 transMap.put("0","男");
 transMap.put("1","女");
 dictionaryTransService.refreshCache("gender",transMap);
//如果字典修改了 需要刷新所有微服务的字典缓存 请调用：
  dictionaryTransService.refreshCacheAndNoticeOtherService("gender",transMap);
```

--------------------------------

### YAML Configuration for Easy Trans

Configuration options for enabling Redis caching, global translation, tiling mode, dictionary caching, custom RPC, and Ruoyi framework integration. Also includes database type and Mybatis-plus version settings.

```yaml
easy-trans:
#启用redis缓存 如果不用redis请设置为false
is-enable-redis:true
#启用全局翻译(拦截所有responseBody进行自动翻译)，如果对于性能要求很高可关闭此配置在方法上使用注解翻译
is-enable-global:true
#启用平铺模式 手动翻译无效
is-enable-tile:true
#字典缓存放到redis 微服务模式请开启
dict-use-redis:true
#使用@RpcTrans来标记哪些类可以进行RPC翻译，默认为关闭，多团队协作推荐开启
is-enable-custom-rpc:true
# ruoyi相关的框架请开启
is-enable-map-result:true
# 反向翻译数据库类型 mysql
db-type:mysql
# Mybatis-plus 为 3.5.3.2版本以上的3.x 版本请设置为true
mp-new:true
```

--------------------------------

### TransProxyController - Java Micro-service Interface

This Java controller exposes micro-service interfaces for findByIds and findById operations. It handles routing based on targetClass and uses SimpleTransService for data retrieval. It includes error handling for illegal access.

```java
@RestController
@RequestMapping("/easyTrans/proxy")
public class TransProxyController {
    private SimpleTransService.SimpleTransDiver simpleTransDiver;

    /**
     * findByIds
     *
     * @param targetClass 目标类
     */
    @PostMapping("/{targetClass}/findByIds")
    public List findByIds(@PathVariable("targetClass") String targetClass, @RequestBody FindByIdsQueryPayload payload) throws ClassNotFoundException {
        Assert.notNull(targetClass, "targetClass 不可为空");
        return simpleTransDiver.findByIds(payload.getIds(), (Class<? extends VO>) Class.forName(targetClass)).stream().map(vo -> {
            try {
                return vo2BasicVO(vo);
            } catch (IllegalAccessException e) {
                return null;
            }
        }).collect(Collectors.toList());
    }

    /**
     * 根据id查询
     *
     * @param targetClass 目标类
     */
    @GetMapping("/{targetClass}/findById/{id}")
    public Object findByIds(@PathVariable("targetClass") String targetClass, @PathVariable("id") String id) throws ClassNotFoundException, IllegalAccessException {
        Assert.notNull(targetClass, "targetClass 不可为空");
        Assert.notNull(targetClass, "id 不可为空");
        return vo2BasicVO(simpleTransDiver.findById(id, (Class<? extends VO>) Class.forName(targetClass)));
    }
}
```

--------------------------------

### RestTemplate Configuration for Micro-services

This Java bean configuration sets up a load-balanced RestTemplate. If a RestTemplate is not explicitly defined by the user, this configuration will be used. This is crucial for inter-service communication.

```java
@Bean
@LoadBalanced
@ConditionalOnMissingBean(RestTemplate.class) // 如果你自己注入了，这个就不起作用就会用你自己注入的
public RestTemplate restTemplate(RestTemplateBuilder builder) {
    return builder.build();
}
```

--------------------------------

### Easy-Trans Trans Annotation Parameters

Explains the parameters for the Trans annotation used in Easy-Trans for data translation. Covers data source specification, mapping, field selection, aliasing, and microservice integration.

```APIDOC
Trans Annotation Parameters:

1. type:
   - Specifies the data source for translation.
   - Supported values: TransType.AUTO_TRANS (custom data source), TransType.DICTIONARY (dictionary cache), TransType.SIMPLE (auto table lookup in current service), TransType.RPC (auto call other microservice).

2. key:
   - Specifies the specific data source when type is TransType.AUTO_TRANS or TransType.DICTIONARY.
   - For TransType.DICTIONARY, provide the dictionary group code (e.g., orderStatus).

3. ref:
   - Maps translated data to a specific property in the current POJO.
   - Example: Map userId translation to userName property in a VO.

4. refs:
   - Similar to 'ref' but supports multiple mappings in an array format.
   - Note: Tiling mode is recommended as an alternative to ref and refs.

5. target:
   - Specifies the target POJO class when type is TransType.SIMPLE.
   - Example: UserPo.class for userId translation.

6. targetClassName:
   - Specifies the fully qualified name of the target POJO class for TransType.RPC (since v2.2.12, also supported for TransType.SIMPLE).
   - Example: com.ucenter.po.User

7. fields:
   - Specifies which fields from the target class are needed (available for TransType.SIMPLE and TransType.RPC).
   - Supports multiple fields in an array format.

8. alias:
   - Provides an alias for translation results to resolve field name conflicts.
   - Example: Differentiate between createUserId and updateUserId if both map to userName.

9. serviceName:
   - Specifies the microservice name for TransType.RPC.
   - Easy-Trans uses this to find the service instance URL from the registry for RPC calls.

10. serviceContextPath:
    - Specifies the context-path of the remote microservice.
    - Used to configure the context-path for RPC calls to prevent 404 errors.
```

--------------------------------

### Manual and Method Result Translation in Java

Demonstrates manual translation of single objects and batches using TransService, and how to automatically translate method return values using the @TransMethodResult annotation. Also shows how to ignore automatic translation for specific controller methods using @IgnoreTrans.

```java
// Manual Translation
@Autowired
private TransService transService;
transService.transOne(school);
transService.transBatch(schoolList);

// Method Result Translation
@TransMethodResult
public Student getStudent() {
    Student student = new Student();
    student.setTeacherId(1);
    return student;
}

// Ignore Translation
@IgnoreTrans
@GetMapping("/one")
public HttpResult<Student> student() {
    return HttpResult.success(newStudent());
}
```

--------------------------------

### Custom DataSource Setter Implementation

Implement the DataSourceSetter interface to provide custom logic for switching data sources. This allows integration with various Spring data source switching components.

```java
/**
 * 数据源设置
 */
@Component
publicclassMyDataSourceSetterimplementsDataSourceSetter{
    /**
     * 设置数据源
     * @paramdatasourceName 数据源名称
     */
publicvoidsetDataSource(StringdatasourceName){
//切换数据源的方法
}
}
```

--------------------------------

### Context-Path Configuration in easy-trans

Demonstrates how to configure the context path for RPC services in easy-trans. It shows two methods: directly adding a context path to an RpcTransService instance and using the @Trans annotation with serviceContextPath.

```java
@Autowired
private RpcTransService rpcTransService;
// 配置contextpath
rpcTransService.addContextPath("easyTrans", "/api");
// 或者
@Trans(type = TransType.RPC, targetClassName = "com.fhs.test.pojo.School", fields = {"schoolName"}, serviceName = "easyTrans", alias = "middle", serviceContextPath = "/api")
private String middleSchoolId;
```

--------------------------------

### Easy Query Primary Key Identification

Explains how to identify the primary key for Easy Query translations using the '@Id4Trans' annotation.

```Java
// Solution: Use the @Id4Trans annotation to mark the primary key field.
@Id4Trans
private Long id;
private String name;
```

--------------------------------

### MybatisPlusMapperRegistry Error

Fixes the 'is not known to the MybatisPlusMapperRegistry' error by removing the 'spring-boot-devtools' dependency, which can cause class loading issues.

```Java
// Solution: Remove the spring-boot-devtools dependency.
// Example (Maven):
// <dependency>
//     <groupId>org.springframework.boot</groupId>
//     <artifactId>spring-boot-devtools</artifactId>
//     <scope>runtime</scope>
//     <optional>true</optional>
// </dependency>
// --> Remove this dependency
```

--------------------------------

### RPC Translation: Unkonwhost

Addresses the 'unkonwhost' issue in RPC translation, typically caused by a custom RestTemplate missing the '@LoadBalanced' annotation.

```Java
// Cause: Custom RestTemplate without @LoadBalanced annotation.
// Solution: Add @LoadBalanced to your custom RestTemplate configuration.
```

--------------------------------

### Enable Redis for Dictionary Caching

Configure Easy-Trans to use Redis for dictionary caching to improve performance and handle multi-microservice dictionary synchronization. This ensures that if the in-memory cache is empty, the system fetches data from Redis and then populates the memory cache.

```yaml
easy-trans:
  dict-use-redis:true
```

--------------------------------

### MybatisPlusException TableInfoCache Not Found

Resolves the 'MybatisPlusException: xx Not Found TableInfoCache' error by ensuring the POJO's mapper extends BaseMapper.

```Java
// Solution: Ensure your POJO's mapper extends BaseMapper.
public interface MyPojoMapper extends BaseMapper<MyPojo> {
    // ...
}
```

--------------------------------

### Manual RPC Translation with @RpcTrans Annotation

Introduces the @RpcTrans annotation, available from version 3.0.1 and 2.2.12, for manually marking POs that require translation across microservices. This is recommended for scenarios where multiple teams collaborate on a project and need explicit control over inter-service translations.

```Java
@RpcTrans
```

--------------------------------

### Easy-Trans Translation Types and Usage

Demonstrates how to use the @Trans annotation in Java for different translation scenarios: Dictionary translation, SIMPLE translation using a local table, RPC translation for microservices, and AUTO_TRANS for custom data sources. It also shows how to specify target class names and fields for translation.

```Java
@Trans(type= TransType.DICTIONARY,key="sex")
privateInteger sex;

@Trans(type= TransType.SIMPLE,target= School.class,fields="schoolName")
privateString schoolId;

@Trans(type= TransType.RPC,targetClassName="com.fhs.test.pojo.School",fields="schoolName",serviceName="easyTrans",alias="middle")
privateString middleSchoolId;
```

--------------------------------

### Simple Translation No Result

Troubleshoots cases where 'Simple' translation yields no results. It advises checking the target POJO class, using aliases for duplicate fields, and observing SQL queries.

```Java
// Troubleshooting steps for Simple translation:
// 1. Ensure 'target' is the POJO class with @TableName or @Table annotation, not VO/DTO.
// 2. Use aliases for fields with the same name in different tables (e.g., user.name, teacher.name).
// 3. Observe SQL queries to identify potential issues.
```

--------------------------------

### RPC Translation with @Trans Annotation

Demonstrates how to use the @Trans annotation for RPC translation in a micro-service architecture. It specifies the target class, fields to translate, and the service name for the RPC call. This is useful for fetching related data, like a user's nickname, from another service.

```Java
@Trans(type= TransType.RPC,targetClassName="com.fhs.ucenter.pojo.User",fields="userName",serviceName="ucenter")
privateString createUserId;
```

--------------------------------

### RpcTransService - RPC Trans Implementation

This Java class extends SimpleTransService and implements remote procedure calls (RPC) using RestTemplate. It handles `findByIds` and `findById` operations by making HTTP requests to other services and includes error logging for remote call failures.

```java
public class RpcTransService extends SimpleTransService {
    private RestTemplate restTemplate;

    @Override
    public List<? extends VO> findByIds(List<String> ids, Trans tempTrans) {
        Map<String, Object> paramMap = new HashMap<>();
        paramMap.put("ids", ids);
        // 执行远程调用
        try {
            String respJson = restTemplate.postForObject("http://" + tempTrans.serviceName()
                    + "/easyTrans/proxy/" + tempTrans.targetClassName() + "/findByIds", paramMap, String.class);
            return JSONArray.parseArray(respJson, BasicVO.class);
        } catch (Exception e) {
            log.error("trans service执行RPC Trans 远程调用错误:" + tempTrans.serviceName(), e);
        }
        return new ArrayList<>();
    }

    @Override
    public VO findById(String id, Trans tempTrans) {
        // 执行远程调用
        try {
            return restTemplate.getForObject("http://" + tempTrans.serviceName()
                    + "/easyTrans/proxy/" + tempTrans.targetClassName() + "/findById/" + id, BasicVO.class);
        } catch (Exception e) {
            log.error("trans service执行RPC Trans 远程调用错误:" + tempTrans.serviceName(), e);
        }
        return null;
    }
}
```

--------------------------------

### Handling Missing XX类ID Annotation

Provides a solution for cases where the 'XX类ID' annotation is not found. It suggests manually defining a Map<String, String> or Map<String, Object> in the POJO.

```Java
// Solution: Manually define a Map in your POJO.
// For older versions:
Map<String, String> transMap = new HashMap<>();

// For newer versions:
Map<String, Object> transMap = new HashMap<>();
```

--------------------------------

### Easy-Trans @TransDefaultSett Annotation Configuration

This section details the configuration parameters for the @TransDefaultSett annotation in Easy-Trans. It allows setting default fields for translation, aliases, unique keys, data sources, and caching behavior for PO classes.

```APIDOC
TransDefaultSett Annotation Parameters:

1. defaultFields: {} - Specifies the default fields to be translated.
2. defaultAlias: - Sets default aliases for translated fields.
3. uniqueField: - Defines the field name to be used as a unique key.
4. dataSource: - Specifies the name of the data source to use for translation.
5. isAccess: false - Caching expiration strategy. 'true' calculates based on last access time, 'false' calculates based on cache time.
6. cacheSeconds: 5 - Cache duration in seconds.
7. maxCache: 1000 - Maximum number of items to cache.
8. isUseCache: false - Enables or disables caching.
```

--------------------------------

### Enable SIMPLE Translation Caching

Enable caching for SIMPLE translations by annotating the data source PO class with `@TransDefaultSett`. This allows configuration of cache behavior, including enabling caching, setting cache expiration time, maximum cache size, and the cache expiration policy (time-based or access-time-based).

```java
@TransDefaultSett(isUseCache = true, cacheSeconds = 5, maxCache = 1000, isAccess = false)
```

--------------------------------

### Configure RPC Translation Caching

Configure RPC translation caching by injecting `TransCacheManager` and using the `setRpcTransCache` method. This method allows specifying the class to cache and a `TransCacheSett` object to configure cache duration, maximum cache size, and access policy. This configuration should be placed in the consumer's microservice.

```java
@Autowired
private TransCacheManager transCacheManager;

transCacheManager.setRpcTransCache("com.fhs.test.pojo.School",
         SimpleTransService.TransCacheSett.builder().cacheSeconds(20).maxCache(1000).build());
```

--------------------------------

### Internationalized Dictionary Initialization

Explains how to initialize dictionaries for internationalization in Easy-Trans. This involves mapping language-specific values to dictionary codes. The system can be configured to automatically detect the current language using a custom locale getter.

```java
@Autowired
private DictionaryTransService dictionaryTransService;
//字典国际化支持
Map<String,String> transMap =newHashMap<>();
// 如果不要国际化则是  ransMap.put("0","男");  transMap.put("1","女");
transMap.put("0_zh_CN","男");
transMap.put("1_zh_CN","女");
transMap.put("0_en","boy");
transMap.put("1_en","girl");
dictionaryTransService.refreshCache("gender",transMap);
//开启国际化支持，不要国际化的可以去掉 getLanguageTag 可以在spring里取
dictionaryTransService.openI18n(new LocaleGetter(){
@Override
publicStringgetLanguageTag(){
Locale locale = LocaleContextHolder.getLocale();
return locale.toLanguageTag(); //springboot可以国际化可以通过这段代码告诉框架当前语言环境
}
});
```

--------------------------------

### Mybatis Plus Method Not Found (3.5.3.2+)

Explains how to resolve method not found errors in Mybatis Plus versions 3.5.3.2 and above. It requires upgrading Easy Trans to 2.2.5+ and setting 'easy-trans.mp-new: true'.

```Java
// Solution: Upgrade Easy Trans to 2.2.5+ and set 'easy-trans.mp-new: true' in application.properties/yml.
// application.properties:
easy-trans.mp-new=true
```

--------------------------------

### TransSett Annotation Usage

Demonstrates how to apply the TransSett annotation to controller methods to manage field translations. It explains the 'exclude' and 'include' parameters for specifying fields to be translated or excluded from translation.

```Java
@TransSett(exclude = {"B"},include = {"A"})
```

--------------------------------

### Beanutils 'Date' Value Error

Addresses the 'No value specified for 'Date'' error related to Beanutils. It recommends upgrading related Apache packages to version 1.9.x.

```Java
// Solution: Upgrade Apache related packages to version 1.9.x.
// Example (Maven dependency):
// <dependency>
//     <groupId>commons-beanutils</groupId>
//     <artifactId>commons-beanutils</artifactId>
//     <version>1.9.4</version>
// </dependency>
```

--------------------------------

### Redis Cache Key Encoding

Resolves issues with garbled cache keys in Redis when using a custom RedisTemplate. It suggests configuring the key serialization method.

```Java
// Solution: Configure the key serialization method in your custom RedisTemplate.
// Example (conceptual):
// redisTemplate.setKeySerializer(new StringRedisSerializer());
```

--------------------------------

### Empty Fields with Ref/Refs in Collections

Addresses issues where fields are empty when translating collections using 'ref' or 'refs'. It recommends upgrading to version 2.1.12 or later.

```Java
// Solution: Upgrade Easy Trans to version 2.1.12 or later.
```

--------------------------------

### Add Easy-Trans Dependency

Instructions on how to add the Easy-Trans untranslation driver dependency to your project. It specifies the groupId and artifactId, noting changes in groupId for versions 2.3.0 and 3.1.0 onwards.

```xml
<dependency>
<groupId>com.fhs-opensource</groupId>
<artifactId>easy-trans-untrans-driver</artifactId>
<version>2.2.1以上版本都支持</version>
</dependency>
```

--------------------------------

### Partial Data Translation Failure

Addresses issues where only partial data is translated, often due to duplicate IDs in the returned object. It suggests manual translation and using the '@Untrans' annotation.

```Java
// Solution: If duplicate IDs exist in the returned object, perform manual translation.
// Mark the controller method with @Untrans to disable automatic translation for that method.
@Untrans
public List<MyObject> getMyObjects() {
    // ...
    return translatedObjects;
}
```

--------------------------------

### Ignoring Field Translation

Explains how to manually handle translation and ignore automatic translation for a specific method using the '@IgnoreTrans' annotation.

```Java
// Solution: Switch to manual translation and use @IgnoreTrans on the method to ignore.
@IgnoreTrans
public String translateMyField() {
    // Manual translation logic
    return "translated value";
}
```

--------------------------------

### Specify Data Source in @Trans Annotation

When using the @Trans annotation for cross-database translations, specify the target data source using the `dataSource` attribute. This ensures the translation is performed against the correct database.

```java
@Trans(type= TransType.SIMPLE,target= User.class,alias="createUser",fields="userName",dataSource="basic")
privateLong createUser;
```

--------------------------------

### Bean Searcher Pagination Translation Issue

Resolves the problem where paginated results from Bean Searcher are not translated correctly. It suggests upgrading to version 2.1.11.

```Java
// Solution: Upgrade Easy Trans to version 2.1.11 or later.
```

--------------------------------

### 配置 uniqueField 缓存

通过 `transCacheManager.setUniqueFieldCache()` 方法配置指定类的缓存匹配字段。此功能允许根据除主键外的其他字段（如身份证号码）来匹配缓存数据。请注意，uniqueField 不能与主键字段相同。

```java
transCacheManager.setUniqueFieldCache("com.xx.User","idNo");
```

--------------------------------

### Easy-Trans Tile Mode Data Structure

Demonstrates the JSON data structure when the tile mode is disabled versus when it is enabled in Easy-Trans. Without tile mode, translated fields are nested within a 'transMap'. With tile mode enabled, translated fields are flattened to the top level.

```JSON
{
  "name": "zhangsan",
  "friendUserId": 1,
  "transMap": {
    "friendUserName": "小明"
  }
}
```

```JSON
{
  "name": "zhangsan",
  "friendUserId": 1,
  "friendUserName": "小明"
}
```

--------------------------------

### Clear SIMPLE and RPC Translation Cache

Clear the SIMPLE and RPC translation caches for a specific class and identifier within the current microservice and potentially other microservices. This operation relies on Redis for broadcasting the clear cache command to other services.

```java
@Autowired
private TransCacheManager transCacheManager;

transCacheManager.clearCache(User.class,"1");
```

--------------------------------

### Troubleshooting Frontend JSON Translation Issues

If the frontend JSON response is not translated, it might be because global translation was disabled. In such cases, you need to manually add the translation annotation to the controller method. Refer to the 'Basic Usage' section of the documentation for details.

```Java
// If global translation is disabled, manually add the annotation to the controller method.
// Example:
// @Translatable
// public User getUserById(@PathVariable Long id) {
//     // ... method implementation ...
// }
```

--------------------------------

### Disable Redis Auto-configuration

If Redis is not used, disable its auto-configuration by excluding `RedisAutoConfiguration.class` in the Spring Boot application.

```java
@SpringBootApplication(exclude={ RedisAutoConfiguration.class })
```

--------------------------------

### Dictionary Translation with @UnTrans

Demonstrates how to use the @UnTrans annotation for dictionary-based translation. It shows mapping a dictionary value (e.g., '男') to its corresponding code (e.g., gender code 0) by referencing a dictionary named 'gender'.

```java
privateString genderName =
"男;
@UnTrans(type=UnTransType.DICTIONARY,dict="gender",refs = {"genderName"})
private Integer gender;
```
Tokens:
Raw