spring boot enum

Spring Boot Enum是一种在Spring Boot项目中使用的特性，它允许开发者将常量数据组织成枚举类型。枚举（Enum）是Java语言提供的一种特殊的数据类型，它将一组相关的值封装在一起，并可以给每个值赋予有意义的名称。

在Spring Boot中，使用Enum可以帮助简化配置管理、提高代码清晰度，并且可以进行类型安全的操作。例如，你可以创建一个表示用户角色的Enum，如`UserRole`: `ADMIN`, `USER`, 然后在配置文件或数据库中直接引用这些枚举名，而不是硬编码整数值。

此外，Spring Boot还支持自动注册枚举类型的值作为@ConfigurationProperties，这意味着你可以轻松地通过配置来注入这些枚举实例。这有助于在运行时动态调整应用程序的行为。

相关问题

spring boot 多数据源_Spring Boot2(四)：使用Spring Boot多数据源实现读写分离

在Spring Boot应用中使用多数据源可以实现读写分离，提高系统的性能和可用性，同时也可以满足不同业务场景下的需求。下面我们来介绍如何使用Spring Boot多数据源实现读写分离。

1. 添加依赖

在pom.xml文件中添加以下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.10</version>
</dependency>

其中，spring-boot-starter-jdbc是Spring Boot提供的JDBC Starter，用于连接数据库。druid是阿里巴巴开源的数据库连接池。

2. 配置数据源

在application.yml文件中添加数据源配置：

spring:
  datasource:
    master:
      url: jdbc:mysql://localhost:3306/test1?useUnicode=true&characterEncoding=utf-8&useSSL=false
      username: root
      password: 123456
      driver-class-name: com.mysql.jdbc.Driver
    slave:
      url: jdbc:mysql://localhost:3306/test2?useUnicode=true&characterEncoding=utf-8&useSSL=false
      username: root
      password: 123456
      driver-class-name: com.mysql.jdbc.Driver

其中，我们配置了两个数据源：master和slave。分别连接了两个不同的数据库，用于实现读写分离。

3. 配置数据源和事务管理器

在Spring Boot中，我们需要自己配置数据源和事务管理器。可以在代码中通过@Primary和@Qualifier注解实现数据源的动态切换。

@Configuration
public class DataSourceConfig {

    @Bean(name = "masterDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.master")
    public DataSource masterDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean(name = "slaveDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.slave")
    public DataSource slaveDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean(name = "dynamicDataSource")
    @Primary
    public DynamicDataSource dynamicDataSource(@Qualifier("masterDataSource") DataSource masterDataSource,
                                               @Qualifier("slaveDataSource") DataSource slaveDataSource) {
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DynamicDataSource.DataSourceType.MASTER, masterDataSource);
        targetDataSources.put(DynamicDataSource.DataSourceType.SLAVE, slaveDataSource);
        return new DynamicDataSource(masterDataSource, targetDataSources);
    }

    @Bean(name = "transactionManager")
    public DataSourceTransactionManager transactionManager(@Qualifier("dynamicDataSource") DynamicDataSource dynamicDataSource) {
        return new DataSourceTransactionManager(dynamicDataSource);
    }
}

其中，我们定义了DataSourceConfig配置类，用于配置数据源和事务管理器。我们通过@Bean注解创建数据源对象并读取application.yml配置文件中的数据源信息。然后通过@Primary注解指定默认的数据源为Master数据源。最后，我们创建了DynamicDataSource对象，用于动态切换数据源，同时创建了事务管理器对象，用于管理事务。

4. 定义数据源切换注解

我们可以通过自定义注解来实现动态切换数据源。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface TargetDataSource {
    DynamicDataSource.DataSourceType value() default DynamicDataSource.DataSourceType.MASTER;
}

其中，@TargetDataSource注解用于标记数据源类型，我们通过value()方法指定数据源类型，默认为Master数据源。

5. 定义动态数据源

我们可以通过继承AbstractRoutingDataSource类来实现动态数据源的切换。

public class DynamicDataSource extends AbstractRoutingDataSource {

    private DataSource masterDataSource;
    private Map<Object, Object> targetDataSources;

    public DynamicDataSource(DataSource masterDataSource, Map<Object, Object> targetDataSources) {
        this.masterDataSource = masterDataSource;
        this.targetDataSources = targetDataSources;
        super.setDefaultTargetDataSource(masterDataSource);
        super.setTargetDataSources(targetDataSources);
        super.afterPropertiesSet();
    }

    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSourceType();
    }

    public enum DataSourceType {
        MASTER, SLAVE
    }
}

其中，我们定义了DynamicDataSource类，继承了AbstractRoutingDataSource类。在DynamicDataSource类中，我们重写了determineCurrentLookupKey()方法，根据当前线程的数据源类型，返回对应的数据源。我们通过枚举类型DataSourceType定义了Master和Slave两种数据源类型。

6. 实现数据源切换

我们可以通过AOP的方式，在方法执行前切换数据源。

@Aspect
@Component
public class DataSourceAspect {

    @Pointcut("@annotation(com.example.demo.annotation.TargetDataSource)")
    public void dataSourcePointCut() {

    }

    @Around("dataSourcePointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        MethodSignature signature = (MethodSignature) point.getSignature();
        TargetDataSource dataSource = signature.getMethod().getAnnotation(TargetDataSource.class);
        if (dataSource == null) {
            DataSourceContextHolder.setDataSourceType(DynamicDataSource.DataSourceType.MASTER);
        } else {
            DataSourceContextHolder.setDataSourceType(dataSource.value());
        }
        try {
            return point.proceed();
        } finally {
            DataSourceContextHolder.clearDataSourceType();
        }
    }
}

其中，我们定义了DataSourceAspect切面类，用于切换数据源。我们通过@Around注解标记了切点，在方法执行前，根据注解中指定的数据源类型，切换数据源。执行完毕后，再切换回默认的Master数据源。

7. 编写业务代码

最后，我们编写业务代码，通过@TargetDataSource注解指定数据源类型。

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    @TargetDataSource(DynamicDataSource.DataSourceType.MASTER)
    public void addUser(User user) {
        userMapper.addUser(user);
    }

    @Override
    @TargetDataSource(DynamicDataSource.DataSourceType.SLAVE)
    public User getUserById(int id) {
        return userMapper.getUserById(id);
    }
}

其中，我们定义了UserServiceImpl类，实现了UserService接口。在addUser()方法中，我们指定数据源类型为Master数据源，在getUserById()方法中，我们指定数据源类型为Slave数据源。

通过以上步骤，我们就可以实现Spring Boot多数据源的读写分离了。

Spring boot中优雅的实现字典管理

在Spring Boot中，我们可以使用枚举类型来实现字典管理，这样可以提高代码的可维护性和可读性。下面介绍一种优雅的实现字典管理的方式。

1. 定义字典枚举类

首先，我们需要定义一个枚举类来表示字典，例如：

public enum DictionaryEnum {
    GENDER("gender", "性别"),
    EDUCATION("education", "学历"),
    // ...

    private String code;
    private String name;

    DictionaryEnum(String code, String name) {
        this.code = code;
        this.name = name;
    }

    public String getCode() {
        return code;
    }

    public String getName() {
        return name;
    }
}

其中，code表示字典项的编码，name表示字典项的名称。可以根据实际情况添加更多的字典项。

2. 定义字典项枚举类

接下来，我们需要定义每个字典项的枚举类，例如：

public enum GenderEnum {
    MALE("male", "男"),
    FEMALE("female", "女");

    private String code;
    private String name;

    GenderEnum(String code, String name) {
        this.code = code;
        this.name = name;
    }

    public String getCode() {
        return code;
    }

    public String getName() {
        return name;
    }
}

其中，code表示字典项的编码，name表示字典项的名称。可以根据实际情况添加更多的字典项。

3. 定义字典项服务类

接下来，我们需要定义一个字典项服务类，用于获取字典项列表，例如：

@Service
public class DictionaryService {
    public List<DictionaryItemVO> getDictionaryItems(DictionaryEnum dictionaryEnum) {
        List<DictionaryItemVO> items = new ArrayList<>();
        switch (dictionaryEnum) {
            case GENDER:
                for (GenderEnum gender : GenderEnum.values()) {
                    items.add(new DictionaryItemVO(gender.getCode(), gender.getName()));
                }
                break;
            case EDUCATION:
                // ...
                break;
            // ...
        }
        return items;
    }
}

其中，getDictionaryItems方法根据传入的字典枚举类获取对应的字典项列表，并转换为一个包含code和name的字典项视图对象（DictionaryItemVO）列表。

4. 定义字典项视图对象类

字典项视图对象类（DictionaryItemVO）是一个包含code和name的简单JavaBean，例如：

public class DictionaryItemVO {
    private String code;
    private String name;

    public DictionaryItemVO(String code, String name) {
        this.code = code;
        this.name = name;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getName() {
        return name;
    }

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

5. 在Controller中使用字典项服务类

最后，在Controller中使用字典项服务类获取字典项列表，例如：

@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    private DictionaryService dictionaryService;

    @GetMapping("/gender")
    public List<DictionaryItemVO> getGenderDictionaryItems() {
        return dictionaryService.getDictionaryItems(DictionaryEnum.GENDER);
    }

    // ...
}

这样，我们就可以优雅地实现字典管理，提高代码的可维护性和可读性。