糖糖IT

1
package com.eim.filter;
2

3
import org.springframework.core.io.Resource;
4
import org.springframework.core.type.AnnotationMetadata;
5
import org.springframework.core.type.ClassMetadata;
6
import org.springframework.core.type.classreading.MetadataReader;
7
import org.springframework.core.type.classreading.MetadataReaderFactory;
8
import org.springframework.core.type.filter.TypeFilter;
9

10
import java.io.IOException;
11

12
//自定义过滤规则，实现TypeFilter接口，
13
public class MyTypeFilter implements TypeFilter {
14

15
    /**
16
     * 实现match方法，返回true匹配成功，返回false匹配失败
17
     * metadataReader： 读取到当前正在扫描的信息
18
     * metadataReaderFactory： 可以获取到其他任何类信息的
19
     */
20
    @Override
21
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
22
        //获取当前类注解信息
23
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
24
        //获取当前正在扫描类的信息（类型，是否实现接口）
25
        ClassMetadata classMetadata = metadataReader.getClassMetadata();
26
        //获取当前类资源信息（类的路径）
27
        Resource resource = metadataReader.getResource();
28

29
        String className = classMetadata.getClassName();
30
        System.out.println("------------->"+className);
31
        if(className.contains("er")){
32
            return true;
33
        }
34

35
        return false;
36
    }
37
}

1
@ComponentScan(value = "com.eim",
2
        //excludeFilters = @ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class})
3
        includeFilters = {
4
                //@ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class}),
5
                //@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,classes = {BaseService.class})
6
                @ComponentScan.Filter(type = FilterType.CUSTOM,classes = {MyTypeFilter.class})
7
        },
8
        useDefaultFilters = false
9
)

1
public class IOCTest {
2

3
    @Test
4
    public void test01() {
5
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(Mainconfig.class);
6
        String[] names = applicationContext.getBeanDefinitionNames();
7
        for (String name : names) {
8
            System.out.println(name);
9
        }
10
    }
11
}

1
//配置类==配置文件
2
@Configuration
3
@ComponentScan(value = "com.eim")
4
public class MainConditionalconfig {
5

6
    /**
7
     *
8
     * 如果是Windows  bill
9
     * 如果是linux  linux
10
     */
11
    @Conditional({WindowsConditional.class})
12
    @Bean("bill")
13
    public Person person1(){
14
        return new Person("bill",25);
15
    }
16

17
    @Conditional({LinuxConditional.class})
18
    @Bean("linux")
19
    public Person person2(){
20
        return new Person("linux",30);
21
    }
22

23
}

1
public class IOCTest {
2

3
    AnnotationConfigApplicationContext applicationContext
4
            = new AnnotationConfigApplicationContext(MainConditionalconfig.class);
5

6
    @Test
7
    public void test03(){
8
        ConfigurableEnvironment environment = applicationContext.getEnvironment();
9
        //动态获取环境变量的值
10
        String property = environment.getProperty("os.name");
11
        System.out.println("os.name:"+property);
12
        //名字
13
        String[] names = applicationContext.getBeanNamesForType(Person.class);
14
        for (String name : names) {
15
            System.out.println("name="+name);
16
        }
17
        //person对象的map集合
18
        Map<String, Person> personMap = applicationContext.getBeansOfType(Person.class);
19
        System.out.println(personMap);
20
    }
21
}

1
public class WindowsConditional implements Condition {
2

3
    /**
4
     * ConditionContext 判断能使用的上下文（环境）
5
     * AnnotatedTypeMetadata 注释信息
6
     *
7
     */
8
    @Override
9
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
10
        //是否是windons系统
11
        //ioc容器的bean工厂
12
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
13
        //获取到运行时的信息，环境变量，虚拟机环境变量
14
        Environment environment = context.getEnvironment();
15
        //获取类加载器
16
        ClassLoader classLoader = context.getClassLoader();
17
        //获取bean定义的注册类：所有的bean注册在这类中，可以查询和注册bean
18
        BeanDefinitionRegistry registry = context.getRegistry();
19

20
        String property = environment.getProperty("os.name");
21
        if(property.contains("Windows")){
22
            return true;
23
        }
24
        return false;
25
    }
26
}

1
//自定义需要导入的组件
2
public class MyImportSelector implements ImportSelector {
3

4
    //返回值，就是导入到容器中的组件全类名
5
    //AnnotationMetadata:当前标注@Import注解的类的所有注解信息
6
    @Override
7
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
8

9
        return new String[]{"com.eim.bean.Blue"};
10
    }
11
}

1
@Import({Color.class, MyImportSelector.class})

1
public abstract class AbstractBeanFactory extends DefaultSingletonBeanRegistry implements BeanFactory {
2

3
    @Override
4
    public Object getBean(String name) throws BeansException {
5
        Object bean = getSingleton(name);
6
        if (bean != null) {
7
            return bean;
8
        }
9

10
        BeanDefinition beanDefinition = getBeanDefinition(name);
11
        return createBean(name, beanDefinition);
12
    }
13

14
    protected abstract BeanDefinition getBeanDefinition(String beanName) throws BeansException;
15

16
    protected abstract Object createBean(String beanName, BeanDefinition beanDefinition) throws BeansException;
17

18
}

1
small-spring-step-03
2
└── src
3
    ├── main
4
    │   └── java
5
    │       └── cn.bugstack.springframework.beans
6
    │           ├── factory
7
    │           │   ├── config
8
    │           │   │   ├── BeanDefinition.java
9
    │           │   │   └── SingletonBeanRegistry.java
10
    │           │   ├── support
11
    │           │   │   ├── AbstractAutowireCapableBeanFactory.java
12
    │           │   │   ├── AbstractBeanFactory.java
13
    │           │   │   ├── BeanDefinitionRegistry.java
14
    │           │   │   ├── CglibSubclassingInstantiationStrategy.java
15
    │           │   │   ├── DefaultListableBeanFactory.java
16
    │           │   │   ├── DefaultSingletonBeanRegistry.java
17
    │           │   │   ├── InstantiationStrategy.java
18
    │           │   │   └── SimpleInstantiationStrategy.java
19
    │           │   └── BeanFactory.java
20
    │           └── BeansException.java
21
    └── test
22
        └── java
23
            └── cn.bugstack.springframework.test
24
                ├── bean
25
                │   └── UserService.java
26
                └── ApiTest.java

1
public Constructor<?> getDeclaredConstructor(Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException

1
import java.lang.reflect.Constructor;
2
public class Example {
3
    public static void main(String[] args) {
4
        try {
5
            Class<?> clazz = MyClass.class;
6

7
            // 获取声明的构造方法，这里假设 MyClass 有一个参数为 int 的构造方法
8
            Constructor<?> constructor = clazz.getDeclaredConstructor(int.class);
9

10
            // 使用构造方法创建对象
11
            Object obj = constructor.newInstance(42);
12
        } catch (Exception e) {
13
            e.printStackTrace();
14
        }
15
    }
16

17
    static class MyClass {
18
        private int value;
19

20
        // 假设有一个参数为 int 的私有构造方法
21
        private MyClass(int value) {
22
            this.value = value;
23
        }
24
    }
25
}

1
public class CglibSubclassingInstantiationStrategy implements InstantiationStrategy {
2
    @Override
3
    public Object instantiate(BeanDefinition beanDefinition, String beanName, Constructor constructor, Object[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
4
        Enhancer enhancer = new Enhancer();
5
        enhancer.setSuperclass(beanDefinition.getBeanClass());
6
        enhancer.setCallback(new NoOp() {
7
            @Override
8
            public int hashCode() {
9
                return super.hashCode();
10
            }
11
        });
12
        if (null == constructor) return enhancer.create();
13
        return enhancer.create(constructor.getParameterTypes(), args);
14
    }
15
}

1
small-spring-step-04
2
└── src
3
    ├── main
4
    │   └── java
5
    │       └── cn.bugstack.springframework.beans
6
    │           ├── factory
7
    │           │   ├── config
8
    │           │   │   ├── BeanDefinition.java
9
    │           │   │   ├── BeanReference.java
10
    │           │   │   └── SingletonBeanRegistry.java
11
    │           │   ├── support
12
    │           │   │   ├── AbstractAutowireCapableBeanFactory.java
13
    │           │   │   ├── AbstractBeanFactory.java
14
    │           │   │   ├── BeanDefinitionRegistry.java
15
    │           │   │   ├── CglibSubclassingInstantiationStrategy.java
16
    │           │   │   ├── DefaultListableBeanFactory.java
17
    │           │   │   ├── DefaultSingletonBeanRegistry.java
18
    │           │   │   ├── InstantiationStrategy.java
19
    │           │   │   └── SimpleInstantiationStrategy.java
20
    │           │   └── BeanFactory.java
21
    │           ├── BeansException.java
22
    │           ├── PropertyValue.java
23
    │           └── PropertyValues.java
24
    └── test
25
        └── java
26
            └── cn.bugstack.springframework.test
27
                ├── bean
28
                │   ├── UserDao.java
29
                │   └── UserService.java
30
                └── ApiTest.java

1
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory {
2

3
    private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();
4

5
    @Override
6
    protected Object createBean(String beanName, BeanDefinition beanDefinition, Object[] args) throws BeansException {
7
        Object bean = null;
8
        try {
9
            bean = createBeanInstance(beanDefinition, beanName, args);
10
            // 给 Bean 填充属性
11
            applyPropertyValues(beanName, bean, beanDefinition);
12
        } catch (Exception e) {
13
            throw new BeansException("Instantiation of bean failed", e);
14
        }
15

16
        addSingleton(beanName, bean);
17
        return bean;
18
    }
19

20
    protected Object createBeanInstance(BeanDefinition beanDefinition, String beanName, Object[] args) {
21
        Constructor constructorToUse = null;
22
        Class<?> beanClass = beanDefinition.getBeanClass();
23
        Constructor<?>[] declaredConstructors = beanClass.getDeclaredConstructors();
24
        for (Constructor ctor : declaredConstructors) {
25
            if (null != args && ctor.getParameterTypes().length == args.length) {
26
                constructorToUse = ctor;
27
                break;
28
            }
29
        }
30
        return getInstantiationStrategy().instantiate(beanDefinition, beanName, constructorToUse, args);
31
    }
32

33
    /**
34
     * Bean 属性填充
35
     */
36
    protected void applyPropertyValues(String beanName, Object bean, BeanDefinition beanDefinition) {
37
        try {
38
            PropertyValues propertyValues = beanDefinition.getPropertyValues();
39
            for (PropertyValue propertyValue : propertyValues.getPropertyValues()) {
40

41
                String name = propertyValue.getName();
42
                Object value = propertyValue.getValue();
43

44
                if (value instanceof BeanReference) {
45
                    // A 依赖 B，获取 B 的实例化
46
                    BeanReference beanReference = (BeanReference) value;
47
                    value = getBean(beanReference.getBeanName());
48
                }
49
                // 属性填充
50
                BeanUtil.setFieldValue(bean, name, value);
51
            }
52
        } catch (Exception e) {
53
            throw new BeansException("Error setting property values：" + beanName);
54
        }
55
    }
56

57
    public InstantiationStrategy getInstantiationStrategy() {
58
        return instantiationStrategy;
59
    }
60

61
    public void setInstantiationStrategy(InstantiationStrategy instantiationStrategy) {
62
        this.instantiationStrategy = instantiationStrategy;
63
    }
64

65
}

1
small-spring-step-05
2
└── src
3
    ├── main
4
    │   └── java
5
    │       └── cn.bugstack.springframework
6
    │           ├── beans
7
    │           │   ├── factory
8
    │           │   │   ├── config
9
    │           │   │   │   ├── AutowireCapableBeanFactory.java
10
    │           │   │   │   ├── BeanDefinition.java
11
    │           │   │   │   ├── BeanReference.java
12
    │           │   │   │   ├── ConfigurableBeanFactory.java
13
    │           │   │   │   └── SingletonBeanRegistry.java
14
    │           │   │   ├── support
15
    │           │   │   │   ├── AbstractAutowireCapableBeanFactory.java
16
    │           │   │   │   ├── AbstractBeanDefinitionReader.java
17
    │           │   │   │   ├── AbstractBeanFactory.java
18
    │           │   │   │   ├── BeanDefinitionReader.java
19
    │           │   │   │   ├── BeanDefinitionRegistry.java
20
    │           │   │   │   ├── CglibSubclassingInstantiationStrategy.java
21
    │           │   │   │   ├── DefaultListableBeanFactory.java
22
    │           │   │   │   ├── DefaultSingletonBeanRegistry.java
23
    │           │   │   │   ├── InstantiationStrategy.java
24
    │           │   │   │   └── SimpleInstantiationStrategy.java
25
    │           │   │   ├── xml
26
    │           │   │   │   └── XmlBeanDefinitionReader.java
27
    │           │   │   ├── BeanFactory.java
28
    │           │   │   ├── ConfigurableListableBeanFactory.java
29
    │           │   │   ├── HierarchicalBeanFactory.java
30
    │           │   │   └── ListableBeanFactory.java
31
    │           │   ├── BeansException.java
32
    │           │   ├── PropertyValue.java
33
    │           │   └── PropertyValues.java
34
    │           ├── core.io
35
    │           │   ├── ClassPathResource.java
36
    │           │   ├── DefaultResourceLoader.java
37
    │           │   ├── FileSystemResource.java
38
    │           │   ├── Resource.java
39
    │           │   ├── ResourceLoader.java
40
    │           │   └── UrlResource.java
41
    │           └── utils
42
    │               └── ClassUtils.java
43
    └── test
44
        └── java
45
            └── cn.bugstack.springframework.test
46
                ├── bean
47
                │   ├── UserDao.java
48
                │   └── UserService.java
49
                └── ApiTest.java

1
public interface Resource {
2

3
    InputStream getInputStream() throws IOException;
4

5
}

1
package org.example.core.io;
2

3
import cn.hutool.core.lang.Assert;
4

5
import java.io.IOException;
6
import java.io.InputStream;
7
import java.net.HttpURLConnection;
8
import java.net.URL;
9
import java.net.URLConnection;
10

11
public class UrlResource implements Resource{
12

13
    private final URL url;
14

15
    public UrlResource(URL url) {
16
        Assert.notNull(url,"URL must not be null");
17
        this.url = url;
18
    }
19

20
    @Override
21
    public InputStream getInputStream() throws IOException {
22
        URLConnection con = this.url.openConnection();
23
        try {
24
            return con.getInputStream();
25
        }
26
        catch (IOException ex){
27
            if (con instanceof HttpURLConnection){
28
                ((HttpURLConnection) con).disconnect();
29
            }
30
            throw ex;
31
        }
32
    }
33

34
}

1
package org.example.core.io;
2

3
import java.io.File;
4
import java.io.IOException;
5
import java.io.InputStream;
6
import java.nio.file.Files;
7

8
public class FileSystemResource implements Resource {
9

10
    private final File file;
11

12
    private final String path;
13

14
    public FileSystemResource(File file) {
15
        this.file = file;
16
        this.path = file.getPath();
17
    }
18

19
    public FileSystemResource(String path) {
20
        this.file = new File(path);
21
        this.path = path;
22
    }
23

24
    @Override
25
    public InputStream getInputStream() throws IOException {
26
        return Files.newInputStream(this.file.toPath());
27
    }
28

29
    public final String getPath() {
30
        return this.path;
31
    }
32

33
}

1
package org.example.core.io;
2

3

4
import cn.hutool.core.lang.Assert;
5
import org.example.util.ClassUtils;
6

7
import java.io.FileNotFoundException;
8
import java.io.IOException;
9
import java.io.InputStream;
10

11
public class ClassPathResource implements Resource {
12

13
    private final String path;
14

15
    private ClassLoader classLoader;
16

17
    public ClassPathResource(String path) {
18
        this(path, (ClassLoader) null);
19
    }
20

21
    public ClassPathResource(String path, ClassLoader classLoader) {
22
        Assert.notNull(path, "Path must not be null");
23
        this.path = path;
24
        this.classLoader = (classLoader != null ? classLoader : ClassUtils.getDefaultClassLoader());
25
    }
26

27
    @Override
28
    public InputStream getInputStream() throws IOException {
29
        InputStream is = classLoader.getResourceAsStream(path);
30
        if (is == null) {
31
            throw new FileNotFoundException(
32
                    this.path + " cannot be opened because it does not exist");
33
        }
34
        return is;
35
    }
36
}

1
package org.example.test;
2

3
import cn.hutool.core.io.IoUtil;
4
import org.example.core.io.DefaultResourceLoader;
5
import org.example.core.io.Resource;
6
import org.junit.Before;
7
import org.junit.Test;
8

9
import java.io.IOException;
10
import java.io.InputStream;
11

12

13
public class ResourceTest {
14
    private DefaultResourceLoader resourceLoader;
15

16
    @Before
17
    public void init() {
18
        resourceLoader = new DefaultResourceLoader();
19
    }
20

21
    @Test
22
    public void test_classpath() throws IOException {
23
        Resource resource = resourceLoader.getResource("classpath:important.properties");
24
        InputStream inputStream = resource.getInputStream();
25
        String content = IoUtil.readUtf8(inputStream);
26
        System.out.println(content);
27
    }
28

29
    @Test
30
    public void test_file() throws IOException {
31
        Resource resource = resourceLoader.getResource("src/test/java/resources/important.properties");
32
        InputStream inputStream = resource.getInputStream();
33
        String content = IoUtil.readUtf8(inputStream);
34
        System.out.println(content);
35
    }
36

37
    @Test
38
    public void test_url() throws IOException {
39
        // Resource resource = resourceLoader.getResource("https://github.com/fuzhengwei/small-spring/important.properties");
40
        Resource resource = resourceLoader.getResource("https://github.com/fuzhengwei/small-spring/blob/main/important.properties");
41
        InputStream inputStream = resource.getInputStream();
42
        String content = IoUtil.readUtf8(inputStream);
43
        System.out.println(content);
44
    }
45
}

1
small-spring-step-06
2
└── src
3
    ├── main
4
    │   └── java
5
    │       └── cn.bugstack.springframework
6
    │           ├── beans
7
    │           │   ├── factory
8
    │           │   │   ├── config
9
    │           │   │   │   ├── AutowireCapableBeanFactory.java
10
    │           │   │   │   ├── BeanDefinition.java
11
    │           │   │   │   ├── BeanFactoryPostProcessor.java
12
    │           │   │   │   ├── BeanPostProcessor.java
13
    │           │   │   │   ├── BeanReference.java
14
    │           │   │   │   ├── ConfigurableBeanFactory.java
15
    │           │   │   │   └── SingletonBeanRegistry.java
16
    │           │   │   ├── support
17
    │           │   │   │   ├── AbstractAutowireCapableBeanFactory.java
18
    │           │   │   │   ├── AbstractBeanDefinitionReader.java
19
    │           │   │   │   ├── AbstractBeanFactory.java
20
    │           │   │   │   ├── BeanDefinitionReader.java
21
    │           │   │   │   ├── BeanDefinitionRegistry.java
22
    │           │   │   │   ├── CglibSubclassingInstantiationStrategy.java
23
    │           │   │   │   ├── DefaultListableBeanFactory.java
24
    │           │   │   │   ├── DefaultSingletonBeanRegistry.java
25
    │           │   │   │   ├── InstantiationStrategy.java
26
    │           │   │   │   └── SimpleInstantiationStrategy.java
27
    │           │   │   ├── support
28
    │           │   │   │   └── XmlBeanDefinitionReader.java
29
    │           │   │   ├── BeanFactory.java
30
    │           │   │   ├── ConfigurableListableBeanFactory.java
31
    │           │   │   ├── HierarchicalBeanFactory.java
32
    │           │   │   └── ListableBeanFactory.java
33
    │           │   ├── BeansException.java
34
    │           │   ├── PropertyValue.java
35
    │           │   └── PropertyValues.java
36
    │           ├── context
37
    │           │   ├── support
38
    │           │   │   ├── AbstractApplicationContext.java
39
    │           │   │   ├── AbstractRefreshableApplicationContext.java
40
    │           │   │   ├── AbstractXmlApplicationContext.java
41
    │           │   │   └── ClassPathXmlApplicationContext.java
42
    │           │   ├── ApplicationContext.java
43
    │           │   └── ConfigurableApplicationContext.java
44
    │           ├── core.io
45
    │           │   ├── ClassPathResource.java
46
    │           │   ├── DefaultResourceLoader.java
47
    │           │   ├── FileSystemResource.java
48
    │           │   ├── Resource.java
49
    │           │   ├── ResourceLoader.java
50
    │           │   └── UrlResource.java
51
    │           └── utils
52
    │               └── ClassUtils.java
53
    └── test
54
        └── java
55
            └── cn.bugstack.springframework.test
56
                ├── bean
57
                │   ├── UserDao.java
58
                │   └── UserService.java
59
                ├── common
60
                │   ├── MyBeanFactoryPostProcessor.java
61
                │   └── MyBeanPostProcessor.java
62
                └── ApiTest.java

1
    @Override
2
    public void refresh() throws BeansException {
3
        // 1. 创建 BeanFactory，并加载 BeanDefinition
4
        refreshBeanFactory();
5

6
        // 2. 获取 BeanFactory
7
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
8

9
        // 3. 在 Bean 实例化之前，执行 BeanFactoryPostProcessor (Invoke factory processors registered as beans in the context.)
10
        invokeBeanFactoryPostProcessors(beanFactory);
11

12
        // 4. BeanPostProcessor 需要提前于其他 Bean 对象实例化之前执行注册操作
13
        //因为bean后置处理器是用于修改实例化对象后的操作，所以必须得提前于实例化对象前进行注册。
14
        registerBeanPostProcessors(beanFactory);
15

16
        // 5. 提前实例化单例Bean对象
17
        beanFactory.preInstantiateSingletons();
18
    }