@Configuration
public class RedisConfiguration {

    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        GenericFastJsonRedisSerializer fastJsonRedisSerializer = new GenericFastJsonRedisSerializer();
        redisTemplate.setDefaultSerializer(fastJsonRedisSerializer);//设置默认的Serialize，包含 keySerializer & valueSerializer
        redisTemplate.setKeySerializer(fastJsonRedisSerializer);//单独设置keySerializer
        redisTemplate.setValueSerializer(fastJsonRedisSerializer);//单独设置valueSerializer
        return redisTemplate;
    }
}

@RestController
@Api(tags = "demo")
@RequestMapping("/v1/demo/")
@Slf4j
public class RedisDemo {
    @Autowired
    private RedisTemplate redisTemplate;

    @ApiOperation(value = "get")
    @PostMapping("get")
    @ResponseBody
    public Object get(String key) {
        ValueOperations valueOperations = redisTemplate.opsForValue();
        Object val = valueOperations.get(key);
        return val;
    }

    @ApiOperation(value = "set")
    @PostMapping("set")
    @ResponseBody
    public Boolean set(String key,String val) {
        ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set(key,val);
        return true;
    }

    @ApiOperation(value = "delete")
    @PostMapping("delete")
    @ResponseBody
    public Boolean delete(String key) {
        return redisTemplate.delete(key);
    }
}

public static void stream(String[] args) {
        Optional<Integer> result = Stream.of("f", "ba", "hello") // of返回Stream<String>对象
                .map(s -> s.length()) // map返回Stream<Integer>对象
                .filter(l -> l <= 3) // filter返回Stream<Integer>对象
                .max((o1, o2) -> o1 - o2); // max终止操作：返回Optional<Integer>
        System.out.println(result.get()); // 输出2
    }

public class MyFuncInterface {
    /**
     * 声明一个函数式接口
     * @param <T>
     */
    @FunctionalInterface
    public interface ToLongFunction<T> {
        long applyAsLong(T value);
    }

    /**
     * 工具函数定义使用函数接口作为参数
     */
    public static class Util{
         public static Long mapToLong(ToLongFunction<? super Collection> mapper, List<String> val) {
            Objects.requireNonNull(mapper);
            return mapper.applyAsLong(val);
        }
    }

    /**
     * 使用例子
     * @param args
     */
    public static void main(String[] args) {
        List<String> arr = Arrays.asList("ddd", "222", "3333");
        Long size = Util.mapToLong((item)-> item.size(),arr);
        System.out.println(size);
    }
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Label {
    String value() default "";
}

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE) public @interface SuppressWarnings {    String[] value();
}

import lombok.Getter;
import lombok.Setter;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Field;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimeZone;

public class AnnotationTestAll {
    /**
     * 自定义注解 Format
     */
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.FIELD)
    public @interface Format {
        String pattern() default "yyyy-MM-dd HH:mm:ss";

        String timezone() default "GMT+8";
    }
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.FIELD)
    public @interface Label {
        String value() default "";
    }
    /**
     * 通过反射 Format Label，并且获取值做运算
     */
    public static class SimpleFormatter {
        public static String format(Object obj) {
            try {
                Class<?> cls = obj.getClass();
                StringBuilder builder = new StringBuilder();
                for (Field field : cls.getDeclaredFields()) {
                    if (!field.isAccessible()) {
                        field.setAccessible(true);
                    }
                    // 获取Label注解-输出的字段名称
                    Label label = field.getAnnotation(Label.class);
                    String name = null == label ? field.getName() : label.value();
                    Object value = field.get(obj);
                    if (value != null && field.getType() == Date.class) {
                        value = formatter(field, value);
                    }
                    builder.append(String.format("%s ? %s \n", name, value));
                }
                return builder.toString();
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException("格式化输出失败：" + e.getMessage());
            }
        }

        private static Object formatter(Field field, Object value) {
            Format format = field.getAnnotation(Format.class);
            if (null == format) {
                return value;
            }
            String pattern = format.pattern();
            String timezone = format.timezone();
            SimpleDateFormat sdf = new SimpleDateFormat(pattern);
            sdf.setTimeZone(TimeZone.getTimeZone(timezone));
            return sdf.format(value);
        }
    }

    /**
     * 测试的一个bo
     */
    @Getter
    @Setter
    public static class Student {
        @Label("姓名")
        private String name;
        @Label("出生日期")
        @Format(pattern = "yyyy/MM/dd")
        private Date born;
        @Label("分数")
        private Double score;
    }

    /**
     * 测试运算结果
     * @param args
     */
    public static void main(String[] args) {
        Student student = new Student();
        student.setBorn(new Date());
        student.setName("张三");
        student.setScore(244.0);
        System.out.println(SimpleFormatter.format(student));
        /**
         * 输出：
         * 姓名 ? 张三
         * 出生日期 ? 2023/03/12
         * 分数 ? 244.0 
         */
    }
}

public class Apple<T> {
    // 使用T类型形参定义实际变量
    private T info;

    public T getInfo() {
        return info;
    }

    public void setInfo(T info) {
        this.info = info;
    }

    public Apple(T info) {
        this.info = info;
    }
    public static void main(String[] args) {
        // 创建变量时候指定泛型类型，构造器只能使用对应类型
        Apple<String> a1 = new Apple<>("苹果");
        System.out.printf(a1.getInfo());
        Apple<Double> a2 = new Apple<>(2.13);
        System.out.printf(a2.getInfo()+"");
    }
}

public interface GenericInterface<T> {
    public T get();
    public void set(T t);
    public T delete(T t);
    default T defaultFunction(T t){
        return t;
    }
}

public class GenericFunction {
    public <T> void function(T t) {
    }
    public <T> T functionTwo(T t) {
        return t;
    }
    public <T> String functionThree(T t) {
        return "";
    }
}

/**
 * 1.创建泛型为Number的List类，Integer、Double、Long等都是Number的子类
 *   new ArrayList<>() 等价于 new ArrayList<Number>()
 */
List<Number> numberList = new ArrayList<Number>();

/**
 * 2.添加不同子类
 */
numberList.add(1);//添加Integer类型
numberList.add(0.5);//添加Double类型
numberList.add(10000L);//添加Long类型

/**
 * 3.创建泛型为Number的List类，Integer、Double、Long等都是Number的子类
 *   引用是泛型类别是Number，但具体实现指定的泛型是Integer
 */
List<Number> numberListTwo = new ArrayList<Integer>();//err 异常编译不通过

/**
 * 4.创建泛型为Integer的List类，把该对象的引用地址指向泛型为Number的List
 */
List<Integer> integerList = new ArrayList<Integer>();
List<Number> numberListThree = integerList;//err 异常编译不通过

public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

public void forEach(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        final int expectedModCount = modCount;
        @SuppressWarnings("unchecked")
        final E[] elementData = (E[]) this.elementData;
        final int size = this.size;
        for (int i=0; modCount == expectedModCount && i < size; i++) {
            action.accept(elementData[i]);
        }
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

@Component
public class MyStragtrgyReflexContent implements ApplicationContextAware,InitializingBean {
    private Map<String,MyStragtegy> beanMap ;
    private ApplicationContext applicationContext;
    /**
     * 实现ApplicationContextAware接口，Spring容器会在创建MyStragtrgyReflexContent类之后，
     * 自动调用实现接口的setApplicationContextAware()方法，
     * 调用该方法时，会将ApplicationContext(容器本身)作为参数传给该方法，
     * 我们可以在该方法中将Spring传入的参数ApplicationContext赋给MyStragtrgyReflexContent对象的applicationContext实例变量，因此接下来可以通过该applicationContext实例变量来访问容器本身。
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
    /**
     * 实现InitializingBean接口，该接口提供了afterPropertiesSet方法。
     * spirng容器在初始化bean的时候会执行afterPropertiesSet方法，
     * 我们可以在该方法中调用applicationContext接口提供的getBeansOfType方法获得实现MyStragtegy类的Bean，将之存储至map集合中
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        Map<String,MyStragtegy> map = applicationContext.getBeansOfType(MyStragtegy.class);
        this.beanMap = map;
    }
    public MyStragtegy getMyStragtegy(String beanName){
        return this.beanMap.get(beanName);
    }
}

@Service
public class StragtegyReflexService {

    @Autowired
    private MyStragtrgyReflexContent reflexContent;

    public String play(String type){
        MyStragtegy myStragtegy = reflexContent.getMyStragtegy(type);
        if (myStragtegy!=null){
            return myStragtegy.play();
        }else {
            return "还没有这个宠物哟！~";
        }
    }

}

org.springframework.context.annotation.internalConfigurationAnnotationProcessor // 注解配置处理
org.springframework.context.annotation.internalAutowiredAnnotationProcessor // 自动注入处理
org.springframework.context.annotation.internalCommonAnnotationProcessor // 通用注解处理
org.springframework.context.event.internalEventListenerProcessor // 事件处理类
org.springframework.context.event.internalEventListenerFactory // 事件监听类

@FunctionalInterface
public interface BeanFactoryPostProcessor {
	/**
	 * Modify the application context's internal bean factory after its standard
	 * initialization. All bean definitions will have been loaded, but no beans
	 * will have been instantiated yet. This allows for overriding or adding
	 * properties even to eager-initializing beans.
	 * @param beanFactory the bean factory used by the application context
	 * @throws org.springframework.beans.BeansException in case of errors
	 */
	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;

}

package org.springframework.beans.factory.config;

import org.springframework.beans.BeansException;
import org.springframework.lang.Nullable;

/**
 * Factory hook that allows for custom modification of new bean instances —
 * for example, checking for marker interfaces or wrapping beans with proxies.
 */
public interface BeanPostProcessor {

	@Nullable
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

	@Nullable
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

}

package engineer.spring.design;

import java.util.ArrayList;
import java.util.List;

/**
 * 模板方法设计模式
 *
 * @author Q
 */
public class TemplateMethodTest {
    public static void main(String[] args) {

        MyBeanFactory beanFactory = new MyBeanFactory();
        beanFactory.addBeanPostProcessor((bean) -> System.out.println("注入 @Autowired" + bean));
        beanFactory.addBeanPostProcessor((bean) -> System.out.println("注入 @Resource" + bean));
        beanFactory.addBeanPostProcessor((bean) -> System.out.println("注入 @Configuration" + bean));

        System.out.println(beanFactory.getBean());

    }

    static class MyBeanFactory {
        public Object getBean() {
            Object bean = new Object();
            System.out.println("构造 " + bean);
            // 1. 解析@Autowired
            // 2. 解析@Resource
            System.out.println("依赖注入 " + bean);
            postProcessorList.forEach(beanPostProcessor -> {
                beanPostProcessor.inject(bean);
            });
            System.out.println("初始化 " + bean);
            // 扩展功能需要修改代码
            return bean;
        }

        public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
            postProcessorList.add(beanPostProcessor);
        }

        private List<BeanPostProcessor> postProcessorList = new ArrayList<>();

    }

    static interface BeanPostProcessor {
        // 依赖注入模板方法，通过调用接口，具体得实现将某些步骤推迟到子类中实现
        void inject(Object bean);
    }

}