markdown复制代码  面向对象：强调的是对象（实体）。冰箱自带打开、存储、关闭等功能。
      冰箱打开
      冰箱存储
      冰箱关闭

typescript复制代码范例：
    public class Car {
        private int num;//汽车轮子数量
        private String color;//汽车车身颜色

        public int getNum() {
            return num;
        }

        public String getColor() {
            return color;
        }

        public void setNum(int num) {
            this.num = num;
        }

        public void setColor(String color) {
            this.color = color;
        }

        @Override
        public String toString() {
            return "Car{" +
                    "num=" + num +
                    ", color='" + color + '\'' +
                    '}';
        }
    }

    主函数{
        Car car = new Car();//car就是一个类类型的引用变量，指向了该类的对象
    }
    
    匿名对象：当对象方法仅进行一次调用时，就可以简化成匿名对象。
        范例：
            new Car().getColor();

markdown复制代码好处：
    将变化隔离。
    便于使用。
    提高重用性。
    提高安全性。
封装原则：
    将不需要对外提供的内容都隐藏起。
    把属性都隐藏，提供公共方法对其访问。

private:
    私有，是一个权限修饰符，用于修饰成员。
    私有的内容只在本类中有效。

markdown复制代码作用：
    给对象进行初始化。————构建创造对象时调用的函数。

注意：
    1）默认构造函数的特点。
        创建对象都必须要通过构造函数初始化。
        一个类中如果没有定义过构造函数，那么类中会有一个默认的空构造函数。如果定义了制定的构造函数，那么类中的默认构造函数就没有了。

    2）多个构造函数是以重载的形式存在的。

和一般函数区别：
    构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。
    一般函数：对象创建后，需要函数功能时才调用。

    构造函数：对象创建时，会调用只调用一次。
    一般函数：对象创建后，可调用多次。

什么时候定义构造函数呢？
    在描述事物时，该事物已存在就具备的一些内容，这些内容都定义在构造函数中。

kotlin复制代码什么时候使用this关键字呢？
    当在函数类需要调用该函数的对象时。
    当局部变量和成员变量重名，可以用关键字this来区分。

this调用构造函数时注意：
    只能定义在构造函数的第一行，因为初始化动作要先执行。

基本应用：
    判断是否为同龄人：
        public boolean compare(Person p){
            return this.age == p.age;
        }

markdown复制代码被修饰后的成员具有以下特点：
    1）随着类的加载而加载。
    2）优先于对象存在。
    3）被所有对象共享。
    4）可以直接被类名调用。

使用注意：
    1）静态方法只能访问静态成员。
    2）静态方法中不可以写this、super关键字。
    3）主函数是静态的。

成员变量和静态变量的区别？
    1） 两个变量的生命周期不一样：
        成员变量随着对象的创建而存在，随着对象的被回收而释放。
        静态变量随着类的加载而存在，随着类的消失而消失。
    2） 调用方式不同：
        成员变量只能被对象调用。
        静态变量可以被对象调用，还可以被类名调用。
    3）  别名不同：
        成员变量也被成为实例变量。
        静态变量被成为类变量。
    4） 数据存储位置不同：
        成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据。
        静态变量数据存储在方法区中。（方法区中的静态区）

静态代码块：
    随着类的加载而加载，而且只执行一次。

    作用：
        用于给类进行初始化。因为有的类不需要对象，可直接调用静态代码块。


静态方法和构造方法的区别？
    静态方法：随着类的加载而加载，而且只执行一次。
    构造方法：是给对应的对象进行针对性的初始化。
    构造代码块：可以给所有对象进行初始化。

scala复制代码java支持多层（多重继承）。
    c继承b，b继承a。就会出现继承体系，当要使用一个继承体系时：
        查看该体系中的顶层类，了解该体系的基本功能。
        创建体系中的最子类对象，完成功能的使用。


好处：
    提高了代码的复用性。
    让类与类之间产生了关系，给第三个特征多态提供了前提。

什么时候定义继承呢？
    当类与类之间存在所属关系的时候，就定义继承。xxx是yyy中的一种，xxx就可以继承yyy的一种。
    所属关系： is a 关系。

具体的体现：
    在子父类之中：
        1）成员变量。
            当本类中的成员和局部变量同名重名用this区分。
            当子父类中的成员变量同名用super区分为父类。

            this和super的区别：
                this代表本类对象的引用。
                super代表父类的空间。
            范例：
            calss fu{
                int num = 4;
            }

            class zi extends fu{
                int num = 5;
                void show(){
                    sout(this.num + "加" + super.num);
                }
            }
            主函数：{
                zi z = new zi();
                z.show();
            }
            打印：4加5

        2）成员函数。
            当子父类中出现成员函数一模一样的情况下：
                会运行子类的函数。这种现象被称为覆盖操作。
            函数的两个特性：
                1）重载：同一个类中。overload。
                2）覆盖（重写）：子类中，覆盖也成为重写（复写）。override。

                    重写注意事项：
                        1）子类方法重写父类方法时，子类权限必须要大于等于父类的权限。
                        2）静态只能重写静态，或被静态重写。
                    
                    什么时候使用重写操作？
                        当对一个类进行子类的扩展时，子类需要保留的功能声明，但需要定义子类中该功能的特有内容时，就使用重写操作完成。
                        
            范例：
            calss fu{
                void show(){
                    sout("old num");
                }
            }

            class zi extends fu{
                void show(){
                    sout("new pic");
                    sout("new img");
                    this.show();
                }
            }
            主函数：{
                zi z = new zi();
                z.show();
            }

        3）构造函数。
            在子类构造对象时，发现访问子类构造函数时，父类也运行了，原因是：在子类的构造函数中，第一行有一个隐式语句。super();————调用父类的构造函数。

            子类的实例化过程：子类中所有的构造函数默认都会访问父类中的空参数的构造函数。

scala复制代码特点：
    1）方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰，抽象方法必须定义在抽象类中。该类必须也被abstract修饰。
    2）抽象类不可以被实例化。为什么？因为调用抽象方法没有意义。
    3）抽象类必须由其子类重写了所有的抽象方法后，该子类才可以实例化，否则，这个子类还是抽象类。

范例：
 abstract calss 犬科{
     abstract void 吼叫();
 }

 class 狗 extends 犬科{
     sout("汪汪");
 }

 class 狼 extends 犬科{
     sout("嗷~~嗷~~");
 }

提出抽象类的五个问题：
    1）抽象类中有构造函数吗？
        有，用于给其子类进行初始化。

    2）抽象类可以不定义抽象方法吗？
        可以，但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。通常这个类中有方法体，但是没有内容。
    
    3）抽象关键字不可以和哪些关键字共存？
        private 不行 ———— 因为抽象方法必须被重写。非法修饰符组合。
        static  不行 ———— 如果成员变静态，则不需要对象，抽象方法即无意义。
        final   不行 ———— 因为无法被重写。
    
    4）抽象类和一般类的异同点？
        异： 一般类有足够的信息描述事物。抽象类描述事物的信息可能不足。
            一般类中不能第一抽象方法，只能定义非抽象方法。抽象类中可以定义抽象方法，同时可以定义非抽象方法。
            一般类可以被实例化。抽象类不可以被实例化。
        同：都是用来描述事物的，都在内部定义了成员。
    
    5）抽象类一定是一个父类吗？
        一定是父类。
        因为某个类继承了抽象类，一定要重写其所有抽象方法才可以对其实例化，否则该类还是抽象类！

csharp复制代码格式：
    interface {}

接口中的成员修饰符都是固定的：
    1）成员常量（全局变量）：public static final
    2）成员函数（抽象方法）：public abstract
    3）发现接口中的成员都是public的
由此得出结论：接口中的成员都是公共的权限。

接口不再使用继承，使用 implements 来实现接口。

范例：
    interface demo{
        public static final int num = 4;
        void show();
    }

    calss demoImpl implements demo{
        @Override
        public void show(){
            sout("我是一个接口中抽象方法的实现方法"); 
        }
    }

在java中不支持多继承，因为会出现调用的不确定性。
所以java将多继承机制进行了改良，在java中变成了多实现。
一个类可以实现多个接口。

范例：
    class Test implements 接口一,接口二{
        方法体;
    }

一个类在继承另一个类的同时，还可以实现多个接口。接口的出现避免了单继承的局限性。

细节：
    类与类之间是继承关系。
    类与接口之间是实现关系。
    接口与接口之间是继承关系。而且接口可以多继承。实现子接口时需重写子接口及所有父接口的所有抽象方法。

特点：
    1）接口是对外暴露的规则。
    2）接口是程序的功能拓展。
    3）接口的出现降低了耦合性。
    4）接口可以用来多实现。
    5）类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
    6）接口和接口之间可以有继承关系。

凡是对外暴露的东西都可以被称之为接口。


接口类与抽象类的异同点？
    
    同：都是不断向上抽取而来的。

    异： 1）抽象类需要被继承，而且只能单继承。接口需要被实现，而且可以多实现。
        2） 抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
            接口中只能定义抽象方法，必须由子类区实现。
        3） 抽象类的继承是 is a 关系。在定义该体系基本共性内容。
            接口的实现是 like a 关系。在定义该体系额外功能。

ini复制代码例子：父类 名 = new 子类();
    动物中猫。狗。
    猫这个对象对应的类型就是猫类型。猫 x = new 猫();
    同时猫也是动物中的一种们也可以把猫称为动物。动物 y = new 猫();
    动物是猫和狗等具体事物中抽取出来的父类型，父类型引用指向了子类对象。

对象的多态性。
    猫这类事物即具有猫的形态，又具备着动物的形态。这就是对象的多态性。
    简单说就是一个对象对应着不同类型。

多态在代码中的体现：
    父类或者接口的引用指向其子类的对象。

python复制代码x_value = np.random.randint(50,100,50)
y_value = np.random.randint(500,1000,50)

python复制代码import matplotlib.pyplot as plt
import numpy as np

plt.rcParams["font.sans-serif"]=['SimHei'] plt.rcParams["axes.unicode_minus"]=False

x_value = np.random.randint(50,100,50)
y_value = np.random.randint(500,1000,50)

plt.scatter(x_value,y_value)

plt.title("data analyze")
plt.xlabel("销售价格")
plt.ylabel("销售额")

plt.show()

python复制代码size = (20*np.random.rand(50))**2
plt.scatter(x_value,y_value,s=area,c="#88c999",edgecolors="pink")

python复制代码x_value = 100*np.random.rand(100)
y_value = 100*np.random.rand(100)

python复制代码r0 = 80
plt.scatter(x_value,y_value,c="hotpink",edgecolors="blue")
the =  np.arange(0,np.pi/2, 0.01)
plt.plot(r0*np.cos(the),r0*np.sin(the))

python复制代码x_value = 100*np.random.rand(100)
y_value = 100*np.random.rand(100)
y1_value = 100*np.random.rand(100)

plt.scatter(x_value,y_value, c="hotpink",edgecolors="blue",label="A产品")

plt.scatter(x_value,y1_value, c="#88c999", edgecolors="y",label="B产品")

python复制代码r0 = 80

size = (20*np.random.rand(100))**2

r = np.sqrt(x_value**2+y_value**2)
area = np.ma.masked_where(r > r0,size)
area1 = np.ma.masked_where(r <= r0, size)

plt.scatter(x_value,y_value,s=area,c="hotpink",edgecolors="blue",label="A产品")

plt.scatter(x_value, y_value, s=area1, c="red", edgecolors="y",marker="^",label="B产品")

the =  np.arange(0,np.pi/2, 0.01)
plt.plot(r0*np.cos(the),r0*np.sin(the))

python复制代码size = (20*np.random.rand(100))**2
color = np.random.randint(0,100,100)
plt.scatter(x_value,y_value, s=size, c=color,label="A产品",cmap="afmhot_r")
plt.colorbar()

python复制代码x_value = list(range(1, 100))
y_value = [x ** 2 for x in x_value]

plt.scatter(x_value,y_value,c=y_value,cmap="hot_r",edgecolors="none",s=50)

plt.show()

java复制代码@Configuration
@EnableConfigurationProperties(TestProperties.class)
@ConditionalOnProperty(prefix = "test", name = "enable")
public class AutoTestConfiguration {
    @Bean
    @ConditionalOnMissingBean
    public TestBean testBean(TestProperties properties){
        System.out.println("this is executed.....");
        return new TestBean();
    }
}

java复制代码@ConfigurationProperties(prefix = "test")
public class TestProperties {
    private boolean enable = true;
    public boolean isEnable() {
        return enable;
    }
    public void setEnable(boolean enable) {
        this.enable = enable;
    }
}

java复制代码@Configuration // 可以被 spring 扫描
@ConfigurationProperties(prefix = "test")
public class TestProperties {
    private boolean enable = true;
    public boolean isEnable() {
        return enable;
    }
    public void setEnable(boolean enable) {
        this.enable = enable;
    }
}

java复制代码@SpringBootApplication
public class Application implements ApplicationListener<ApplicationReadyEvent> {
   @Autowired
   private ApplicationContext applicationContext;
   public static void main(String[] args) {
      SpringApplication.run(Application.class, args);
   }
   @Override
   public void onApplicationEvent(ApplicationReadyEvent event) {
      System.out.println(this.applicationContext.getEnvironment().getProperty("test.enable")  + "------");
   }
}

properties复制代码test.enable=true

ruby复制代码Parameter 0 of method testBean in com.glmapper.bridge.boot.config.AutoTestConfiguration required a single bean, but 2 were found:
	- testProperties: defined in file [/Users/glmapper/Documents/project/exception-guides/target/classes/com/glmapper/bridge/boot/config/TestProperties.class]
	- test-com.glmapper.bridge.boot.config.TestProperties: defined in null

java复制代码class EnableConfigurationPropertiesRegistrar implements ImportBeanDefinitionRegistrar {
         .getQualifiedAttributeName(EnableConfigurationPropertiesRegistrar.class, "methodValidationExcludeFilter");

   @Override
   public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
      registerInfrastructureBeans(registry);
      registerMethodValidationExcludeFilter(registry);
      ConfigurationPropertiesBeanRegistrar beanRegistrar = new ConfigurationPropertiesBeanRegistrar(registry);
      // to register
      getTypes(metadata).forEach(beanRegistrar::register);
   }

java复制代码private String getName(Class<?> type, MergedAnnotation<ConfigurationProperties> annotation) {
    // 拿 prefix
   String prefix = annotation.isPresent() ? annotation.getString("prefix") : "";
   // prefix + "-" + 类全限定名 
   return (StringUtils.hasText(prefix) ? prefix + "-" + type.getName() : type.getName());
}

arduino复制代码[ConfigurationPropertySourcesPropertySource {name='configurationProperties'}, 
StubPropertySource {name='servletConfigInitParams'}, 
StubPropertySource {name='servletContextInitParams'}, 
PropertiesPropertySource {name='systemProperties'}, OriginAwareSystemEnvironmentPropertySource {name='systemEnvironment'}, 
RandomValuePropertySource {name='random'}, 
OriginTrackedMapPropertySource {name='Config resource 'class path resource [application.properties]' via location 'optional:classpath:/''}]

java复制代码public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
    // 1、没有 Conditional 注解，则扫描时不会跳过当前 bean
    // 2、遍历 conditions 进行判断是否满足
}

yml复制代码pages_low = pages_min*5/4
pages_high = pages_min*3/2

shell复制代码
[root@centos7-2 ~]# free -h -c 2 -s 2

java复制代码 // @Service
public class OrderServiceImpl implements OrderService {

    @Transactional
    public void updateOrder(Order order) {
        // update order
    }
}

java复制代码@Service
public class OrderServiceImpl implements OrderService {

    public void update(Order order) {
        updateOrder(order);
    }

    @Transactional
    public void updateOrder(Order order) {
        // update order 逻辑
    }
}

java复制代码@Resource
private UpdateOrder updateOrder;

public void update(Order order) {
      updateOrder.updateOrder(order);
}

java复制代码@Service
public class OrderServiceImpl implements OrderService {

    @Transactional
    public void updateOrder(Order order) {
        try {
            // update order
        } catch {
        
        }
    }
}

java复制代码@Service
public class OrderServiceImpl implements OrderService {

    @Transactional
    public void updateOrder(Order order) {
        try {
            // update order
        } catch {
            throw new Exception("更新错误");
        }
    }

}

java复制代码@Transactional(rollbackFor = Exception.class)

java复制代码@Service
public class OrderServiceImpl implements OrderService {

    @Transactional
    public void updateOrder(Order order) {
        try {
            // update order
        } catch {
            logger.error("更改订单失败")
            throw new RuntimeException("RuntimeException");
        }
    }
}

java复制代码@Service
public class OrderServiceImpl implements OrderService {

    @Transactional(rollbackFor = { Exception.class })
    public void updateOrder(Order order) {
        try {
            // update order
        } catch {
            logger.error("更改订单失败")
            throw e;
        }
    }
}

java复制代码@Service
public class OrderServiceImpl implements OrderService {

    @Transactional
    public int updateOrder(Order order) {
        try {
            // update order
        } catch {
            logger.error("更改订单失败")
            //手动回滚
            TransactionAspectSupport.currentTransactionStatus()
            .setRollbackOnly();
            return 0;
        }
        return 1;
    }
}

c复制代码int * pa = &a;

c复制代码int a = 10;
int * pa = &a;

c复制代码int a = 0x11223344;
int* pa = &a;
*pa = 0;

c复制代码int arr[10] = { 0 };
//1.
int* pa = arr;
//2.
char * pa = arr;
for (int i = 0; i < 10; i++)
{
    *(pa + i) = 1;
}

c复制代码 int* p;//未初始化 
 *p = 20;

c复制代码int arr[10] = { 0 };
int* p = arr;
for (int i = 0; i <= 10; i++)//越界访问
{
    *(p + i) = i;
}

c复制代码 int* test(){
 	int a = 10;
 	return &a;
 }
 int main(){
 	int* p = test();
 	printf("%d\n", *p);//野指针越界访问
 	return 0;
 }

c复制代码int* test(){
	int a = 10;
	return &a;
}
int main(){
	int* p = test();
	printf("hehe\n");
	printf("%d\n", *p);
	return 0;
}

c复制代码int* test(){
 int a = 10;
 return &a;
}
int main(){
 int* p = test();
 *p = 20;//访问非法内存
 return 0;
}

c复制代码 int* p = &a;
 int* p =NULL;//不知道该指向何处时，置为空NULL

c复制代码if(p != NULL){
    *p=20;//检验不为空指针，再使用
}

c复制代码float values[N_VALUE];
float* vp = values;
for (vp = &values[0]; vp < &values[N_VALUE];)
{
    *vp++=0;
}

c复制代码int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
printf("%d\n", &arr[9] - &arr[0]);

c复制代码int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
char ch[] = { '1','2','3' };
printf("%d\n", &arr[9] - &ch[0]);

c复制代码int my_strlen(const char* s){
    char* begin = s;//标记开头
    while(*s++);//s先++再判断是否为\0
    return s - begin - 1;//指针相减
}

c复制代码//1.
for(vp = &values[N_VALUE];vp > &values[0];){
    *--vp = 0;
}

c复制代码//2.
for(vp = &values[N_VALUE-1];vp >= &values[0];vp--){
    *vp = 0;
}

c复制代码int arr[10] = { 0 };
printf("%p\n", arr);//0x0012ff40
printf("%p\n", &arr[0]);//0x0012ff40

c复制代码int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;
for (int i = 0; i < sz; i++)
{
    printf("&arr[%d] = %p <===> p+%d = %p\n", i, &arr[i], i, p + i);
}

c复制代码*p = 1;
* *pp = 2;
* * *ppp = 3;

c复制代码int arr[10] = {0};
//整型数组 - 存放整型变量的数组
char ch[10] = {'0'};
//字符数组 - 存放字符变量的数组

c复制代码//整型指针数组
int* parr[10];
//字符型指针数组
char* pch[5];

c复制代码int arr[] = { 10,20,30 };
int* parr[5] = {NULL};
//输入
for (int i = 0; i < 3; i++)
{
    parr[i] = &arr[i];
}
//输出1.
for (int i = 0; i < 3 ; i++)
{
    printf("%d ", *parr[i]);
}
//输出2.
for (int i  = 0; i < 3; i++)
{
    printf("%d ", **(parr+i));
}

xml复制代码<!--   阿里云oss存储     -->
<dependency>
    <groupId>com.aliyun.oss</groupId>
    <artifactId>aliyun-sdk-oss</artifactId>
    <version>3.13.2</version>
</dependency>

yml复制代码# 阿里云oss
aliyun:
  oss:
    endpoint: oss-cn-shanghai.aliyuncs.com
    accessKeyId: LTAI5tH********Cr88dn
    accessKeySecret: ayKgKy4BY********0gLaUI9
    bucketName: yourname

java复制代码@Component
public class OssClient {

    @Value("${aliyun.oss.endpoint}")
    private String endpoint;

    @Value("${aliyun.oss.bucketName}")
    private String bucketName;

    @Value("${aliyun.oss.accessKeyId}")
    private String accessKeyId;

    @Value("${aliyun.oss.accessKeySecret}")
    private String accessKeySecret;

    @Bean
    public OSS getOSSClient() {
        return new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
    }
}

java复制代码@RestController
@RequestMapping("/oss")
public class OSSController {

    @Autowired
    OSS ossClient;
    
    @Value("${aliyun.oss.endpoint}")
    private String endpoint;

    @Value("${aliyun.oss.bucketName}")
    private String bucketName;

    @Value("${aliyun.oss.accessKeyId}")
    private String accessKeyId;

    @ApiOperation("获取签名policy")
    @GetMapping("/policy")
    public Map<String, String> policy() {
        // host的格式为 bucketname.endpoint
        String host = "https://" + bucketName + "." + endpoint;
        // callbackUrl为上传回调服务器的URL，请将下面的IP和Port配置为您自己的真实信息。
        // String callbackUrl = "http://88.88.88.88:8888";
        String today = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
        // 按日期分文件夹存储
        String dir = today + "/"; // 用户上传文件时指定的前缀。
        Map<String, String> respMap = null;
        try {
            long expireTime = 30;
            long expireEndTime = System.currentTimeMillis() + expireTime * 1000;
            Date expiration = new Date(expireEndTime);
            // PostObject请求最大可支持的文件大小为5 GB，即CONTENT_LENGTH_RANGE为5*1024*1024*1024。
            PolicyConditions policyConds = new PolicyConditions();
            policyConds.addConditionItem(PolicyConditions.COND_CONTENT_LENGTH_RANGE, 0, 1048576000);
            policyConds.addConditionItem(MatchMode.StartWith, PolicyConditions.COND_KEY, dir);

            String postPolicy = ossClient.generatePostPolicy(expiration, policyConds);
            byte[] binaryData = postPolicy.getBytes(StandardCharsets.UTF_8);
            String encodedPolicy = BinaryUtil.toBase64String(binaryData);
            String postSignature = ossClient.calculatePostSignature(postPolicy);

            respMap = new LinkedHashMap<String, String>();
            respMap.put("accessid", accessKeyId);
            respMap.put("policy", encodedPolicy);
            respMap.put("signature", postSignature);
            respMap.put("dir", dir);
            respMap.put("host", host);
            respMap.put("expire", String.valueOf(expireEndTime / 1000));
            // respMap.put("expire", formatISO8601Date(expiration));
        } catch (Exception e) {
            // Assert.fail(e.getMessage());
            System.out.println(e.getMessage());
        } finally {
            ossClient.shutdown();
        }
        return respMap;
    }
}

json复制代码{
    "accessid": "LTAI5tHZ1ro3zUUuZmCr88dn",
    "policy": "eyJleHBpcmF0aW9uIj1iMjAyMS0xMS0xNVQwOTozODowOS4zOThaIiwiY29uZGl0aW9ucyI6W1siY29udGVudC1sZW5ndGgtcmFuZ2UiLDAsMTA0ODU3NjAwMF0sWyJzdGFydHMtd2l0aCIsIiRrZXkiLCIyMDIxLTExLTE1LyJdXX0=",
    "signature": "3K/6hXZPCYCNBwUFBaec7CmAa70=",
    "dir": "2021-11-15/",
    "host": "https://thinkfon-member.oss-cn-shanghai.aliyuncs.com",
    "expire": "1636969089"
}

xml复制代码<dependencies>
    <!-- 邮件发送的核心依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

java复制代码@Slf4j
public class SecurityInterceptor implements HandlerInterceptor {
    /**
     * 在执行具体的Controller方法之前调用
     *
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 一个简单的安全校验，要求请求头中必须包含 req-name : yihuihui
        String header = request.getHeader("req-name");
        if ("yihuihui".equals(header)) {
            return true;
        }

        log.info("请求头错误: {}", header);
        return false;
    }

    /**
     * controller执行完毕之后被调用，在 DispatcherServlet 进行视图返回渲染之前被调用，
     * 所以我们可以在这个方法中对 Controller 处理之后的 ModelAndView 对象进行操作。
     * <p>
     * preHandler 返回false，这个也不会执行
     *
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        log.info("执行完毕!");
        response.setHeader("res", "postHandler");
    }


    /**
     * 方法需要在当前对应的 Interceptor 类的 preHandle 方法返回值为 true 时才会执行。
     * 顾名思义，该方法将在整个请求结束之后，也就是在 DispatcherServlet 渲染了对应的视图之后执行。此方法主要用来进行资源清理。
     *
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        log.info("回收");
    }
}

java复制代码@RestController
@SpringBootApplication
public class Application implements WebMvcConfigurer {

    public static void main(String[] args) {
        SpringApplication.run(Application.class);
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new SecurityInterceptor()).addPathPatterns("/**");
    }

    @GetMapping(path = "show")
    public String show() {
        return UUID.randomUUID().toString();
    }
}

yaml复制代码security:
  check: yihuihui

java复制代码@Component
public class SpringUtil implements ApplicationContextAware, EnvironmentAware {
    private static ApplicationContext applicationContext;
    private static Environment environment;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringUtil.applicationContext = applicationContext;
    }

    @Override
    public void setEnvironment(Environment environment) {
        SpringUtil.environment = environment;
    }

    public static <T> T getBean(Class<T> clz) {
        return applicationContext.getBean(clz);
    }

    public static String getProperty(String key) {
        return environment.getProperty(key);
    }
}

java复制代码@Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 一个简单的安全校验，要求请求头中必须包含 req-name : yihuihui
        String header = request.getHeader("req-name");
        if (Objects.equals(SpringUtil.getProperty("security.check"), header)) {
            return true;
        }

        log.info("请求头错误: {}", header);
        return false;
    }

java复制代码@Bean
public SecurityInterceptor securityInterceptor() {
    return new SecurityInterceptor();
}

@Override
public void addInterceptors(InterceptorRegistry registry) {
    registry.addInterceptor(securityInterceptor()).addPathPatterns("/**");
}

bash复制代码yihui@M-162D9NNES031U:SpringBlog git:(master) $ curl 'http://127.0.0.1:8080/show' -H 'req-name:yihuihui' -i
HTTP/1.1 200
Content-Type: text/plain;charset=UTF-8
Content-Length: 36
Date: Mon, 15 Nov 2021 10:56:30 GMT

6610e593-7c60-4dab-97b7-cc671c27762d%