//单个对元素执行给定的动作，如果有剩下元素未处理返回true，否则返回false
 boolean tryAdvance(Consumer<? super T>action);

//对每个剩余元素执行给定的动作，依次处理，直到所有元素已被处理或被异常终止。默认方法调用tryAdvance方法
default void forEachRemaining(Consumer<? super T>action){
        do{}while(tryAdvance(action));
        }

        //对任务分割，返回一个新的Spliterator迭代器
        Spliterator<T> trySplit();

        //用于估算还剩下多少个元素需要遍历
        long estimateSize();

//当迭代器拥有SIZED特征时，返回剩余元素个数；否则返回-1
default long getExactSizeIfKnown(){
        return(characteristics()&SIZED)==0?-1L:estimateSize();
        }

        //返回当前对象有哪些特征值
        int characteristics();

//是否具有当前特征值
default boolean hasCharacteristics(int characteristics){
        return(characteristics()&characteristics)==characteristics;
        }
//如果Spliterator的list是通过Comparator排序的，则返回Comparator
//如果Spliterator的list是自然排序的 ，则返回null
//其他情况下抛错
default Comparator<? super T>getComparator(){
        throw new IllegalStateException();
        }

static final class ArrayListSpliterator<E> implements Spliterator<E> {
    //用于存放ArrayList对象
    private final ArrayList<E> list;
    //起始位置（包含），advance/split操作时会修改
    private int index;
    //结束位置（不包含），-1 表示到最后一个元素
    private int fence;
    //用于存放list的modCount
    private int expectedModCount;

    ArrayListSpliterator(ArrayList<E> list, int origin, int fence,
                         int expectedModCount) {
        this.list = list;
        this.index = origin;
        this.fence = fence;
        this.expectedModCount = expectedModCount;
    }

    //获取结束位置（存在意义：首次初始化石需对fence和expectedModCount进行赋值）
    private int getFence() {
        int hi;
        ArrayList<E> lst;
        //fence<0时（第一次初始化时，fence才会小于0）：
        if ((hi = fence) < 0) {
            //list 为 null时，fence=0
            if ((lst = list) == null)
                hi = fence = 0;
            else {
                //否则，fence = list的长度。
                expectedModCount = lst.modCount;
                hi = fence = lst.size;
            }
        }
        return hi;
    }

    //分割list，返回一个新分割出的spliterator实例
    public ArrayListSpliterator<E> trySplit() {
        //hi为当前的结束位置
        //lo 为起始位置
        //计算中间的位置
        int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
        //当lo>=mid,表示不能在分割，返回null
        //当lo<mid时,可分割，切割（lo，mid）出去，同时更新index=mid
        return (lo >= mid) ? null :
                new ArrayListSpliterator<E>(list, lo, index = mid, expectedModCount);
    }

    //返回true 时，只表示可能还有元素未处理
    //返回false 时，没有剩余元素处理了。。。
    public boolean tryAdvance(Consumer<? super E> action) {
        if (action == null)
            throw new NullPointerException();
        //hi为当前的结束位置
        //i 为起始位置
        int hi = getFence(), i = index;
        //还有剩余元素未处理时
        if (i < hi) {
            //处理i位置，index+1
            index = i + 1;
            @SuppressWarnings("unchecked") E e = (E) list.elementData[i];
            action.accept(e);
            //遍历时，结构发生变更，抛错
            if (list.modCount != expectedModCount)
                throw new ConcurrentModificationException();
            return true;
        }
        return false;
    }

    //顺序遍历处理所有剩下的元素
    public void forEachRemaining(Consumer<? super E> action) {
        int i, hi, mc; // hoist accesses and checks from loop
        ArrayList<E> lst;
        Object[] a;
        if (action == null)
            throw new NullPointerException();
        if ((lst = list) != null && (a = lst.elementData) != null) {
            //当fence<0时，表示fence和expectedModCount未初始化，可以思考一下这里能否直接调用getFence()，嘿嘿？
            if ((hi = fence) < 0) {
                mc = lst.modCount;
                hi = lst.size;
            } else
                mc = expectedModCount;
            if ((i = index) >= 0 && (index = hi) <= a.length) {
                for (; i < hi; ++i) {
                    @SuppressWarnings("unchecked") E e = (E) a[i];
                    //调用action.accept处理元素
                    action.accept(e);
                }
                //遍历时发生结构变更时抛出异常
                if (lst.modCount == mc)
                    return;
            }
        }
        throw new ConcurrentModificationException();
    }

    public long estimateSize() {
        return (long) (getFence() - index);
    }

    public int characteristics() {
        //打上特征值：、可以返回size
        return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
    }
}

 List<String> arrs=new ArrayList<>();
        arrs.add("a");
        arrs.add("b");
        arrs.add("c");
        arrs.add("d");
        arrs.add("e");
        arrs.add("f");
        arrs.add("h");
        arrs.add("i");
        arrs.add("j");
        Spliterator<String> a=arrs.spliterator();
        System.out.println(a);
        //此时结果：a:0-9（index-fence）

        Spliterator<String> b=a.trySplit();
        System.out.println(b.toString());
        //此时结果：b:4-9,a:0-4

        Spliterator<String> c=a.trySplit();
        //此时结果：c:4-6,b:4-9,a:6-9
        System.out.println(c.toString());

        Spliterator<String> d=a.trySplit();
        System.out.println(d.toString());
//此时结果：d:6-7,c:4-6,b:4-9,a:7-9

public interface OfPrimitive<T, T_CONS, T_SPLITR extends Spliterator.OfPrimitive<T, T_CONS, T_SPLITR>>
        extends Spliterator<T> {
    @Override
    T_SPLITR trySplit();

    @SuppressWarnings("overloads")
    boolean tryAdvance(T_CONS action);

    @SuppressWarnings("overloads")
    default void forEachRemaining(T_CONS action) {
        do {
        } while (tryAdvance(action));
    }
}

 public interface OfPrimitive<T, T_CONS, T_SPLITR extends Spliterator.OfPrimitive<T, T_CONS, T_SPLITR>> extends Spliterator<T> {
    T_SPLITR trySplit();

    boolean tryAdvance(T_CONS var1);

    default void forEachRemaining(T_CONS var1) {
        while (this.tryAdvance(var1)) {
            ;
        }

    }
}

    private AtomicInteger count=new AtomicInteger(0);
private List<String> strList=createList();
private Spliterator spliterator=strList.spliterator();

/**
 * 多线程计算list中数值的和
 * 测试spliterator遍历
 */
@Test
public void mytest(){
        for(int i=0;i< 4;i++){
        new Thread(()->{
        String threadName=Thread.currentThread().getName();
        System.out.println("   "+threadName+" start ");
        spliterator.trySplit().forEachRemaining((o)->{
        if(isInteger((String)o)){
        int num=Integer.parseInt(o+"");
        count.addAndGet(num);
        System.out.println("数值："+num+"     "+threadName);
        try{
        Thread.sleep(2000);
        }catch(InterruptedException e){
        e.printStackTrace();
        }
        }
        });
        System.out.println("     "+threadName+" end");
        }).start();
        }
        try{
        Thread.sleep(15000);
        }catch(InterruptedException e){
        e.printStackTrace();
        }
        System.out.println("结果为："+count);
        }

private List<String> createList(){
        List<String> result=new ArrayList<>();
        for(int i=0;i< 100;i++){
        if(i%10==0){
        result.add(i+"");
        }else{
        result.add("=");
        }
        }
        return result;
        }

public static boolean isInteger(String str){
        Pattern pattern=Pattern.compile("^[-\\+]?[\\d]*$");
        return pattern.matcher(str).matches();
        }

public @interface 注解名 {
    定义体
}

public class TempServiceDemo {

    @Autowired
    private TempRepository tempRepository;


    public String findAll() {
        return "default";
    }

    @MultiDatabase(name = "second", sourceType = MultiDataSource.SourceType.ORACLE)
    public String findAllSecond() {
        return "second";
    }

    @MultiDatabase(name = "third", sourceType = MultiDataSource.SourceType.MYSQL)
    public String findAllThird() {
        return "third";
    }

}

        //获得要调用的类，一般不会这么获取
Class<TempServiceDemo> tempServiceDemoClass=TempServiceDemo.class;
// 获得要调用的方法，output是要调用的方法名字，new Class[]{}为所需要的参数。空则不是这种
Method currentMethod=null;
        try{
        currentMethod=tempServiceDemoClass.getMethod("findAllSecond",new Class[]{});
        // 是否有类型为MyAnnotation的注解
        if(currentMethod.isAnnotationPresent(MultiDatabase.class)){
        // 获得注解
        MultiDatabase datasource=currentMethod.getAnnotation(MultiDatabase.class);
        // 调用注解的内容
        System.out.println(datasource.name());
        }
        System.out.println("----------------------------------");
        // 获得所有注解。必须是runtime类型的  @Retention(RetentionPolicy.RUNTIME)
        Annotation[]annotations=currentMethod.getAnnotations();
        for(Annotation annotation:annotations){
        // 遍历所有注解的名字
        System.out.println(annotation.annotationType().getName());
        }
        }catch(NoSuchMethodException e){
        //错误处理
        }

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface UserAccess {
    String desc() default "无信息";
}

@After("@annotation(userAccess)")
public void after(JoinPoint jp,UserAccess userAccess){
        log.debug("second after:"+userAccess.desc());
        }

@RestController
public class UserController {
    @RequestMapping("/second")
    @UserAccess(desc = "second")
    public Object second() {
        return "second controller";
    }
}

@Data
@Accessors(chain = true)
@MappedSuperclass//实体集成映射
public class BaseEntity implements Serializable {
    @Id
    @Column(name = "ID")
    @ApiModelProperty(value = "主键")
    private Long id;

    @Basic
    @Column(name = "DEL_STATUS")
    @ApiModelProperty(value = "状态 1启用 0 停用")
    private Integer delStatus;
}

/**
 * 应用接口日志
 *
 * @author author
 * @date 2019-7-23 15:38:57
 */
@Accessors(chain = true)
@Data
@Entity
@Table(name = "app_log_api", schema = "", catalog = "")
@ApiModel(value = "应用接口日志", description = "应用接口日志")
public class AppLogApi extends BaseEntity implements Serializable {
    private static final long serialVersionUID = -1L;

    @Basic
    @Column(name = "API")
    @ApiModelProperty(value = "请求地址")
    private String api;

    @Basic
    @Column(name = "API_CLASS")
    @ApiModelProperty(value = "请求的类.方法")
    private String apiClass;

    /*****/
    public AppLogApi() {
    }
}

/**
 * BaseService
 *
 * @author maxzhao
 * @date 2019-08-15 11:46
 */
public interface BaseService<T extends BaseEntity, ID> {
    /**
     * 逻辑删除
     **********
     */
    ResultObj<String> del(ID id);
}

@Slf4j
@Service(value = "baseService")
public class BaseServiceImpl<T extends BaseEntity, ID> implements BaseService<T, ID> {
    private Class<T> clazz = null;

    {
        Type type = this.getClass().getGenericInterfaces()[0];
        if (type instanceof ParameterizedType) {
            ParameterizedType pType = (ParameterizedType) type;
            Type claz = pType.getActualTypeArguments()[0];
            if (claz instanceof Class) {
                this.clazz = (Class<T>) claz;
            }
        }
    }

    ResultObj<String> del(ID id) {
        return null;
    }
}

{
    Type type=getClass().getGenericSuperclass();
    if(type instanceof ParameterizedType){
    ParameterizedType pType=(ParameterizedType)type;
    Type claz=pType.getActualTypeArguments()[0];
    if(claz instanceof Class){
    this.clazz=(Class<T>)claz;
    }
    }
    }

/**
 * BaseEntity
 * 实体继承映射类基础,保存实体的通用属性
 *
 * @author maxzhao
 * @date 2019-08-15 09:39
 */
@Data
@Accessors(chain = true)
@MappedSuperclass//实体继承映射
public class BaseEntity implements Serializable {
    @Id
    @Column(name = "ID")
    @ApiModelProperty(value = "主键")
    private Long id;

    @Basic
    @Column(name = "DEL_STATUS")
    @ApiModelProperty(value = "状态 1启用 0 停用")
    private Integer delStatus;
}

/**
 * BaseEntityId
 * 实体集成映射类,保存实体的通用属性
 *
 * @author maxzhao
 * @date 2019-08-15 09:39
 */
@Data
@Accessors(chain = true)
@MappedSuperclass//实体集成映射
public class BaseEntityId extends BaseEntity {
    @Basic
    @Column(name = "CREATE_ID")
    @ApiModelProperty(value = "创建人主键")
    private Long createId;

    @Basic
    @Column(name = "CREATE_IP")
    @ApiModelProperty(value = "创建IP")
    private String createIp;


    @Basic
    @Column(name = "CREATE_DATE")
    @ApiModelProperty(value = "创建时间")
    private Timestamp createDate;

    @Basic
    @Column(name = "UPDATE_DATE")
    @ApiModelProperty(value = "修改时间")
    private Timestamp updateDate;

    @Basic
    @Column(name = "UPDATE_ID")
    @ApiModelProperty(value = "修改人主键")
    private Long updateId;

    @Basic
    @Column(name = "UPDATE_IP")
    @ApiModelProperty(value = "修改IP")
    private String updateIp;
}

package gt.maxzhao.boot.common.annotation;

import java.lang.annotation.*;

/**
 * <p>多数据源标识</p>
 * <p>使用方式：必须用在方法上</p>
 *
 * @author maxzhao
 * @date 2019-06-26 16:13
 */
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface MultiDataSource {
    String name() default "main";
}

/**
 * <p>多数据源配置</p>
 * <p>数据库数据源配置</p>
 * <p>说明:这个类中包含了许多默认配置,建议不要修改本类,直接在"application.yml"中配置即可</p>
 *
 * @author maxzhao
 * @date 2019-06-26 16:13
 */
@Component
@ConfigurationProperties(prefix = "spring.datasource")
@Setter
@Getter
@Slf4j
public class DruidProperties {
    public DruidProperties() {
        log.info("default 数据源加载");
    }

    /**
     * 数据源名称
     */
    private String dbName = "main";

    private String url;

    private String username;

    private String password;
    /**
     * 默认为 MYSQL 8.x 配置
     */
    private String driverClassName = "com.mysql.cj.jdbc.Driver";

    private Integer initialSize = 10;

    private Integer minIdle = 3;

    private Integer maxActive = 60;

    private Integer maxWait = 60000;

    private Boolean removeAbandoned = true;

    private Integer removeAbandonedTimeout = 180;

    private Integer timeBetweenEvictionRunsMillis = 60000;

    private Integer minEvictableIdleTimeMillis = 300000;

    private String validationQuery = "SELECT 'x'";

    private Boolean testWhileIdle = true;

    private Boolean testOnBorrow = false;

    private Boolean testOnReturn = false;

    private Boolean poolPreparedStatements = true;

    private Integer maxPoolPreparedStatementPerConnectionSize = 50;

    private String filters = "stat";

    public DruidDataSource config() {
        DruidDataSource dataSource = new DruidDataSource();
        return config(dataSource);
    }

    public DruidDataSource config(DruidDataSource dataSource) {
        dataSource.setDbType(JdbcConstants.MYSQL);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        dataSource.setDriverClassName(driverClassName);
        dataSource.setInitialSize(initialSize);     // 定义初始连接数
        dataSource.setMinIdle(minIdle);             // 最小空闲
        dataSource.setMaxActive(maxActive);         // 定义最大连接数
        dataSource.setMaxWait(maxWait);             // 获取连接等待超时的时间
        dataSource.setRemoveAbandoned(removeAbandoned); // 超过时间限制是否回收
        dataSource.setRemoveAbandonedTimeout(removeAbandonedTimeout); // 超过时间限制多长

        // 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
        dataSource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        // 配置一个连接在池中最小生存的时间，单位是毫秒
        dataSource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        // 用来检测连接是否有效的sql，要求是一个查询语句
        dataSource.setValidationQuery(validationQuery);
        // 申请连接的时候检测
        dataSource.setTestWhileIdle(testWhileIdle);
        // 申请连接时执行validationQuery检测连接是否有效，配置为true会降低性能
        dataSource.setTestOnBorrow(testOnBorrow);
        // 归还连接时执行validationQuery检测连接是否有效，配置为true会降低性能
        dataSource.setTestOnReturn(testOnReturn);
        // 打开PSCache，并且指定每个连接上PSCache的大小
        dataSource.setPoolPreparedStatements(poolPreparedStatements);
        dataSource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
        // 属性类型是字符串，通过别名的方式配置扩展插件，常用的插件有：
        // 监控统计用的filter:stat
        // 日志用的filter:log4j
        // 防御SQL注入的filter:wall
        try {
            dataSource.setFilters(filters);
        } catch (SQLException e) {
            log.error("扩展插件失败.{}", e.getMessage());
        }
        return dataSource;
    }

}

/**
 * <p>多数据源配置</p>
 * <p>多个数据源</p>
 *
 * @author maxzhao
 * @date 2019-06-26 16:22
 */
@Configuration
@ConfigurationProperties(prefix = "gt.maxzhao.boot")
@Getter
@Setter
@Slf4j
public class MultiDataSource {
    public MultiDataSource() {
        log.info("加载多数据源配置信息  -->  {}", "gt.maxzhao.boot.datasource");
    }
    /**
     * 多个数据源
     */
    private List<DruidProperties> datasource;
}

/**
 * <p>多数据源配置</p>
 * <p>多数据源配置</p>
 *
 * @author maxzhao
 * @date 2019-06-26 16:07
 */
@Slf4j
@Component
public class MultiSourceConfig {
    @Autowired
    private DruidProperties druidProperties;

    @Autowired
    private MultiDataSource multiDataSource;


    /**
     * 单数据源连接池配置
     */
    @Bean
    @ConditionalOnProperty(name = "gt.maxzhao.boot.multiDatasourceOpen", havingValue = "false")
    public DruidDataSource singleDatasource() {
        log.error("singleDatasource");
        return druidProperties.config(new DruidDataSource());
    }

    /**
     * 多数据源连接池配置
     */
    @Bean
    @ConditionalOnProperty(name = "gt.maxzhao.boot.multiDatasourceOpen", havingValue = "true")
    public DynamicDataSource mutiDataSource() {
        log.error("mutiDataSource");

        //存储数据源别名与数据源的映射
        HashMap<Object, Object> dbNameMap = new HashMap<>();
        // 核心数据源
        DruidDataSource mainDataSource = druidProperties.config();
        // 这里添加 主要数据库，其它数据库挂了，默认使用主数据库
        dbNameMap.put("main", mainDataSource);
        // 其它数据源
        // 当前多数据源是否存在
        if (multiDataSource.getDatasource() != null) {
            //过滤掉没有添加 dbName 的数据源，先加载娟全局配置，再次加载当前配置
            List<DruidDataSource> multiDataSourceList = multiDataSource.getDatasource().stream()
                    .filter(dp -> !"".equals(Optional.ofNullable(dp.getDbName()).orElse("")))
                    .map(dp -> {
                        DruidDataSource druidDataSource = dp.config(druidProperties.config());
                        dbNameMap.put(dp.getDbName(), druidDataSource);
                        return druidDataSource;
                    })
                    .collect(Collectors.toList());

            // 测试所有的数据源
            try {
                mainDataSource.init();
                for (DruidDataSource druidDataSource : multiDataSourceList) {
                    druidDataSource.init();
                }
            } catch (SQLException sql) {
                log.error("=======================    多数据源配置错误   ==========================");
                sql.printStackTrace();
            }
        }
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        dynamicDataSource.setTargetDataSources(dbNameMap);
        dynamicDataSource.setDefaultTargetDataSource(mainDataSource);
        return dynamicDataSource;
    }

}

/**
 * <p>多数据源配置</p>
 * <p>动态数据源</p>
 * <p>多 datasource 的上下文</p>
 *
 * @author xiongneng
 * @since 2017年3月5日 上午9:11:49
 */
public class DynamicDataSource extends AbstractRoutingDataSource {
    /**
     * <p>多 datasource 的上下文</p>
     * <p>每个线程独立的数据库连接名称</p>
     */
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>();

    /**
     * @param dataSourceDbName 数据库别名
     * @Description: 设置数据源别名
     */
    public static void setDataSourceDbName(String dataSourceDbName) {
        contextHolder.set(dataSourceDbName);
    }

    /**
     * @Description: 获取数据源别名
     */
    public static String getDataSourceDbName() {
        return contextHolder.get();
    }

    /**
     * @Description: 清除数据源别名
     */
    public static void clearDataSourceDbName() {
        contextHolder.remove();
    }

    /**
     * 重写获取连接名称的方法
     * @return 连接名称
     */
    @Override
    protected Object determineCurrentLookupKey() {
        return getDataSourceDbName();
    }

}

/**
 * <p>多数据源切换的 aop</p>
 *
 * @author maxzhao
 * @date 2019-06-26 16:22
 */
@Aspect
@Component
@ConditionalOnProperty(prefix = "gt.maxzhao.boot", name = "multiDatasourceOpen", havingValue = "true")
public class MultiDataSourceAop implements Ordered {
    private Logger log = LoggerFactory.getLogger(this.getClass());

    public MultiDataSourceAop() {
        log.info("多数据源初始化 AOP ");
    }

    @Pointcut(value = "@annotation(gt.maxzhao.boot.common.annotation.MultiDataSource)")
    private void cut() {
    }

    @Around("cut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {

        Signature signature = point.getSignature();
        MethodSignature methodSignature ;
        if (!(signature instanceof MethodSignature)) {
            throw new IllegalArgumentException("该注解只能用于方法");
        }
        methodSignature = (MethodSignature) signature;
        //获取当点方法的注解
        Object target = point.getTarget();
        Method currentMethod = target.getClass().getMethod(methodSignature.getName(), methodSignature.getParameterTypes());

        MultiDataSource datasource = currentMethod.getAnnotation(MultiDataSource.class);
        if (datasource != null) {
            DynamicDataSource.setDataSourceDbName(datasource.name());
            log.debug("设置数据源为：" + datasource.name());
        } else {
            DynamicDataSource.setDataSourceDbName("main");
            log.debug("设置数据源为：默认  -->  main");
        }
        try {
            return point.proceed();
        } finally {
            log.debug("清空数据源信息！");
            DynamicDataSource.clearDataSourceDbName();
        }
    }

    /**
     * aop的顺序要早于spring的事务
     */
    @Override
    public int getOrder() {
        return 1;
    }
}

@Accessors(chain = true)
@Data
@Entity
@Table(name = "temp", schema = "", catalog = "")
public class Temp implements Serializable {
    private static final long serialVersionUID = -1L;

    @Id
    @Column(name = "ID",unique = true)
    @ApiModelProperty(value = "主键")
    private Long id;
    @Basic
    @Column(name = "NAME")
    @ApiModelProperty(value = "地区名称")
    private String name;
}

@Service
@Transactional
public class TempServiceDemo {

    @Autowired
    private TempRepository tempRepository;


    public List<Temp> findAll() {
        return tempRepository.findAll();
    }

    @MultiDataSource(name = "second")
    public List<Temp> findAllSecond() {
        return tempRepository.findAll();
    }

    @MultiDataSource(name = "third")
    public List<Temp> findAllThird() {
        return tempRepository.findAll();
    }
}

@Repository("tempRepository")
public interface TempRepository extends JpaRepository<Temp, Long> {
}

@RunWith(SpringRunner.class )
// 这里的 BasicApplication 是当前SpringBoot的启动类
@SpringBootTest(classes = BasicApplication.class)
@Slf4j
public class MultiDataSourceTest {
    @Resource
    private TempServiceDemo tempServiceDemo;

    @Autowired
    private MultiDataSource multiDataSource;

    @Test
    public void testMultiDataSource() {
        System.out.println("\r\n=================\r\n");
        System.out.println(tempServiceDemo.findAllSecond());
        System.out.println("\r\n=================\r\n");
        System.out.println( tempServiceDemo.findAllThird());
        System.out.println("\r\n=================\r\n");
    }
}

@Autowired
private EntityManager entityManager

@Autowired
private RedisTemplate redisTemplate;
@Autowired
private StringRedisTemplate stringRedisTemplate;
// StringRedisTemplate是继承RedisTemplate的，
// RedisTemplate在StringRedisTemplate中泛型定义为String

public class StringRedisTemplate extends RedisTemplate<String, String> {
    public StringRedisTemplate() {
        this.setKeySerializer(RedisSerializer.string());
        this.setValueSerializer(RedisSerializer.string());
        this.setHashKeySerializer(RedisSerializer.string());
        this.setHashValueSerializer(RedisSerializer.string());
    }

    public StringRedisTemplate(RedisConnectionFactory connectionFactory) {
        this();
        this.setConnectionFactory(connectionFactory);
        this.afterPropertiesSet();
    }

    protected RedisConnection preProcessConnection(RedisConnection connection, boolean existingConnection) {
        return new DefaultStringRedisConnection(connection);
    }
}

@RunWith(SpringRunner.class)
@SpringBootTest(classes = IttestApplication.class)
public class RedisTest {


    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Test
    public void testRedisTemplate() {
        String prefix = "maxzhao:redisTemplate:";
        HashOperations hashOperations = redisTemplate.opsForHash();
        ValueOperations valueOps = redisTemplate.opsForValue();
        ListOperations listOps = redisTemplate.opsForList();
        SetOperations setOps = redisTemplate.opsForSet();
        ZSetOperations zSetOps = redisTemplate.opsForZSet();
        GeoOperations geoOperations = redisTemplate.opsForGeo();
        ClusterOperations clusterOperations = redisTemplate.opsForCluster();
        Map map = Arrays.stream(new String[]{"a", "B"}).collect(Collectors.toMap(Function.identity(), Function.identity()));
        hashOperations.putAll(prefix + "hash", map);
    }

    @Test
    public void testStringRedisTemplate() {
        String prefix = "maxzhao:stringRedisTemplate:";
        HashOperations hashOperations = stringRedisTemplate.opsForHash();
        hashOperations.putAll(prefix + "hash", Arrays.stream(new String[]{"a", "b"}).collect(Collectors.toMap(Function.identity(), Function.identity())));
        hashOperations.putAll(prefix + "hash", Arrays.stream(new String[]{"c", "d"}).collect(Collectors.toMap(Function.identity(), Function.identity())));
        hashOperations.putAll(prefix + "hash", Arrays.stream(new String[]{"e", "f"}).collect(Collectors.toMap(Function.identity(), Function.identity())));
        hashOperations.put(prefix + "hash", "max", "maxvalue");// a b c d e f max
        hashOperations.get(prefix + "hash", "max");// maxvalue
        hashOperations.delete(prefix + "hash", "f");// return 1  database:a b c d e max
        hashOperations.delete(prefix + "hash", "c", "d");// return 2  database:a b e max
        hashOperations.hasKey(prefix + "hash", "max");//return true
        hashOperations.values(prefix + "hash");// return map object
        ValueOperations valueOperations = stringRedisTemplate.opsForValue();
        valueOperations.set(prefix + "value", "value");
        valueOperations.set(prefix + "value", "valueTest");//value 被覆盖
        valueOperations.get(prefix + "value");// return valueTest

        ListOperations listOps = stringRedisTemplate.opsForList();
//        listOps.remove(prefix + "list", listOps.size(prefix + "list"), 1);
        listOps.leftPush(prefix + "list", "A");
        listOps.leftPush(prefix + "list", "B");
        listOps.rightPush(prefix + "list", "C", "D");//只有 1：B  2：A
        listOps.leftPush(prefix + "list", "C");
        listOps.leftPush(prefix + "list", "D");//return 3  1:D 2:C 3:A
        listOps.range(prefix + "list", 0, listOps.size(prefix + "list"));//return 3  0:D 1:C 2:A   list下标从0开始
        listOps.leftPop(prefix + "list");//只有   1：A 返回的为B
        listOps.leftPush(prefix + "list2", "A");
        listOps.leftPush(prefix + "list2", "B");//只有 1：B  2：A
        listOps.rightPush(prefix + "list2", "C");//只有 1：B  2：A 3 C

        // set 是无序的，所有pop等获取value的操作，得到结果可能不同
        SetOperations setOps = stringRedisTemplate.opsForSet();
        setOps.add(prefix + "set", "A");//return 1
        setOps.add(prefix + "set", "A");//return 0
        setOps.add(prefix + "set", "B");//return 1
        setOps.difference(prefix + "set", "A");//return HashSet  A,B
        setOps.isMember(prefix + "set", "A");//return true
        setOps.isMember(prefix + "set", "C");//return false
        setOps.members(prefix + "set");//return HashSet  A,B
        setOps.pop(prefix + "set");// 出序列并删除 1个
        setOps.add(prefix + "set", "A","B", "C", "D", "E");//return 5
        setOps.pop(prefix + "set", 2);// 出序列并删除 2个
        setOps.add(prefix + "set", "A","B", "C", "D", "E");
        setOps.move(prefix + "set", "D", "A");//return  true  database=BCE
        // 把当前key=set的c值，move到 key=set1
        setOps.move(prefix + "set", "C", prefix + "set1");//return  true
        setOps.remove(prefix + "set", "C", "D");//删除
        // 有序的set
        ZSetOperations zSetOps = stringRedisTemplate.opsForZSet();

        GeoOperations geoOperations = stringRedisTemplate.opsForGeo();
        // 只有jedis 和 lettuce 支持Redis Cluster。
        ClusterOperations clusterOperations = stringRedisTemplate.opsForCluster();
        System.out.println("====================");
    }
}

@Component
@ConfigurationProperties(prefix = "spring.redis.cluster")
public class ClusterConfigurationProperties {

    /*
     * spring.redis.cluster.nodes[0] = 127.0.0.1:7379
     * spring.redis.cluster.nodes[1] = 127.0.0.1:7380
     * ...
     */
    List<String> nodes;

    /**
     * Get initial collection of known cluster nodes in format {@code host:port}.
     *
     * @return
     */
    public List<String> getNodes() {
        return nodes;
    }

    public void setNodes(List<String> nodes) {
        this.nodes = nodes;
    }
}

@Configuration
public class AppConfig {

    /**
     * Type safe representation of application.properties
     */
    @Autowired ClusterConfigurationProperties clusterProperties;

    public @Bean RedisConnectionFactory connectionFactory() {

        return new JedisConnectionFactory(
            new RedisClusterConfiguration(clusterProperties.getNodes()));
    }
}