学习Spring(3)Bean

深藏阁楼爱情的钟 2022-10-13 15:52 149阅读 0赞

# Spring Bean #

## Spring中的Bean ##

xml配置文件中的bean元素其实相当于一个实例对象

bean默认是单例模式，也就是不管getBean()方法获取多少遍都是同一个实例对象，但是bean可以设置为多例，就是每次getBean()的创建不同的对象

<bean id="testDaoImpl" class="dao.TestDaoImpl" scope="prototype"/>

#### Bean作用域： ####

singleton：在spring IoC容器仅存在一个Bean实例，Bean以单例方式存在，bean作用域范围的默认值。

prototype：每次从容器中调用Bean时，都返回一个新的实例，即每次调用getBean()时，相当于执行newXxxBean()。

request：每次HTTP请求都会创建一个新的Bean，该作用域仅适用于web的Spring WebApplicationContext环境。

session：同一个HTTP Session共享一个Bean，不同Session使用不同的Bean。该作用域仅适用于web的Spring WebApplicationContext环境。

application：限定一个Bean的作用域为ServletContext的生命周期。该作用域仅适用于web的Spring WebApplicationContext环境。

### 自己实现多例模式 ###

先说一下多例的思想，之前创建对象的工作是在ClassPathXmlApplicationContext的构造函数中就完成的，所以getBean()的时候已经是实例对象了，想了一下整个启动代码只有两句话读取配置文件初始化好容器，直接getBean()，既然不能在ClassPathXmlApplicationContext中，那就只能在getBean()中了

这次顺便把无参构造函数干掉

因为就是在上面自己写的IOC上改，所以目录结构一样：

*  testioc
    
     *  TestIoc(包)
        
         *  BeanFactory.java(接口)
         *  ClassPathXmlApplicationContext.java
         *  MyAnnontationBean.java(注解)
     *  TestService(包)
        
         *  Animal.java(接口)
         *  Cat.java
         *  Dog.java
         *  TestNew(包)
            
             *  Bird.java
     *  MainTest(包)
        
         *  MainTest.java(测试代码)
 *  resources
    
     *  applicationContext.xml(之前就有的配置文件)
     *  bean.xml(新建的配置文件)

修改五个文件：ClassPathXmlApplicationContext.java，MyAnnontationBean.java，bean.xml，Bird.java，MainTest.java

ClassPathXmlApplicationContext.java，这个文件是主要修改的：

package TestIoc;
    import org.dom4j.Document;
    import org.dom4j.Element;
    import org.dom4j.io.SAXReader;
    import org.reflections.Reflections;
    import java.util.*;
    // IOC实现，IOC容器，就是简单重写一个spring中的 ClassPathXmlApplicationContext 类
    /* xml配置文件整个流程： 读取xml配置文件，然后遍历所有的bean元素，获取到 id 和 类名， 然后通过反射Class.forName("类名").newInstance()创建一个实例对象，再将id和实例对象存到一个Map中 最后通过重写的getBean(id)方法，根据 id 返回实例对象 注解的整个流程： 自定义一个带参数的注解 根据自定义的注解在指定包范围内搜索出所有的类 再将注解的参数当作唯一标识，根据注解找到的类实例对象当作值，存入Map中 */
    public class ClassPathXmlApplicationContext implements BeanFactory{ 
        // 容器，用来存放实例对象
        private final Map<String, Map<Object, String>> container = new HashMap<>();
        private final String SCOPES = "singleton";
        // 通过xml配置文件，创建实例对象，因为可以多个文件配置，所以我这里使用了...的形式
        // 不过下面的代码有一个问题，就是你要么选择xml配置，要么选择注解配置，如果两个一个用的话需要保证两边是一致的，不然因为代码运行的顺序，注解会将xml覆盖掉
        public ClassPathXmlApplicationContext(String... fileNames) throws Exception{ 
            // SAXReader是一个DOM解析器，能将路径中的XML文件解析为Document对象
            SAXReader sb = new SAXReader();
            // 因为String...接收的是一个数组，所以这里使用遍历
            for(String filename: fileNames){ 
                // class.getResource("/")会查找classpath根目录
                // 因为我是在一个spring的项目下弄了这个程序，所以classpath路径是target/classes/下，xml文件放在resources就可以了
                // read(xml的路径)转成Document类型对象
                Document doc = sb.read(ClassPathXmlApplicationContext.class.getResource("/"+filename));
                // getRootElement()获取根元素标签，根元素就是beans
                Element root = doc.getRootElement();
                // 从根元素下所有的bean元素
                List<Element> list =  root.elements("bean");
                // 便利所有bean标签元素
                for (Element bean : list) { 
                    // 获取每个bean元素
                    // 根据属性获取数据
                    String id = bean.attributeValue("id");
                    String clazz = bean.attributeValue("class");
                    String scope = bean.attributeValue("scope");
                    if(scope==null){ 
                        scope = SCOPES;
                    }
                    // 通过反射Class.forName("类名")找到类，通过newInstance()创建一个新的实例对象
                    Object obj;
                    // 如果是singleton就是单例，存进去创建好的实例
                    if(scope.equals(SCOPES)){ 
                        // 将类实例化对象
                        // newInstance()将类实例化
                        obj = Class.forName(clazz).newInstance();
                    }else { 
                        // 如果不是，就直接存进去Class对象
                        obj = Class.forName(clazz);
                    }
                    Map<Object, String> newmap = new HashMap<>();
                    newmap.put(obj, scope);
                    // 将实例对象加入容器中
                    container.put(id, newmap);
                }
                // 查找classpathPackage标签，因为可能是多个所以使用list
                List<Element> packages =  root.elements("classpathPackage");
                // 遍历所有classpathPackage标签
                for (Element newpackage: packages) { 
                    // 查找classpathPackage标签的packagePath属性
                    String packagePath = newpackage.attributeValue("packagePath");
                    if(!packagePath.equals("")) { 
                        // 反射的指定范围，在这个包下面，包下面的子包都是包含的
                        // 其实这里不应该写死哪个包，也应该是一个配置文件读取
                        Reflections reflections = new Reflections(packagePath);
                        // 根据指定的注解获取所有的类
                        // getTypesAnnotatedWith()根据指定的注解搜索所有的类
                        Set<Class<?>> classes = reflections.getTypesAnnotatedWith(MyAnnontationBean.class);
                        // 遍历获取到的类
                        for (Class<?> type : classes) { 
                            // 获取注解的参数，就是相当于xml中的id
                            // getAnnotation()获取注解
                            MyAnnontationBean annon = type.getAnnotation(MyAnnontationBean.class);
                            // 注解的参数，就是唯一标识
                            // value()是自定义注解中的方法
                            String value = annon.value();
                            // 这里不需要判断是否存在是因为自定义注解中，我们给了默认值
                            String scope = annon.scope();
                            Object o;
                            // 如果是singleton就是单例，存进去创建好的实例
                            if (scope.equals(SCOPES)) { 
                                // 将类实例化对象
                                // newInstance()将类实例化
                                o = type.newInstance();
                            } else { 
                                // 如果不是，就直接存进去Class对象
                                o = type;
                            }
                            Map<Object, String> newmap = new HashMap<>();
                            newmap.put(o, scope);
                            // 将id和object存入map中
                            container.put(value, newmap);
                        }
                    }
                }
            }
        }
        @Override
        public Object getBean(String id) { 
            Object newobj = null;
            // 根据xml中bean的id找到对应的实例
            Map<Object,String> newmap = container.get(id);
            // 下面的操作是如果是单例就直接返回实例，如果是多例就新创建一个对象再返回
            for(Object obj: newmap.keySet()){ 
                // 如果不是单例，我们就创建一个新对象
                if(!newmap.get(obj).equals(SCOPES)){ 
                    // 这里需要将原本的Class实例强转回来，因为存在Map中是Object
                    Class clazz = (Class) obj;
                    try { 
                        newobj = clazz.newInstance();
                    } catch (InstantiationException e) { 
                        e.printStackTrace();
                    } catch (IllegalAccessException e) { 
                        e.printStackTrace();
                    }
                }else{ 
                    // 如果是单例，我们直接使用Map里的对象
                    newobj = obj;
                }
            }
            // 返回对象
            return newobj;
        }
    }

然后修改注解，添加默认值，MyAnnontationBean.java：

package TestIoc;
    import java.lang.annotation.*;
    // Target 是说明这个注解的使用范围，TYPE是用于描述类、接口(包括注解类型) 或enum声明
    @Target(ElementType.TYPE)
    // Retention 是说明这个注解的保留时间，RUNTIME是在运行时有效（即一直保留到运行时）
    // 注意：这个一定要是运行时，不然反射那边就获取不到参数
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyAnnontationBean { 
        String value();
        // 添加scope属性，默认单例模式
        String scope() default "singleton";
    }

修改bean.xml配置文件：

<?xml version="1.0" encoding="UTF-8"?>
    
    <beans>
        <bean id="cat" class="TestService.Cat" />
        <bean id="dog" class="TestService.Dog" />
        
        <bean id="bird" class="TestService.TestNew.Bird" scope="prototype"/>
        
        
        <classpathPackage packagePath="TestService"/>
    </beans>

修改Bird.java：

package TestService.TestNew;
    import TestIoc.MyAnnontationBean;
    import TestService.Animal;
    // 注解形式修改为多例模式
    @MyAnnontationBean(value = "bird", scope = "prototype")
    public class Bird implements Animal { 
        @Override
        public void say() { 
            System.out.println("渣渣渣！！！");
        }
    }

修改测试代码，MainTest.java：

package MainTest;
    import TestIoc.BeanFactory;
    import TestIoc.ClassPathXmlApplicationContext;
    import TestService.Animal;
    import org.testng.annotations.Test;
    public class MainTest { 
        @Test
        void test() throws Exception { 
            // 读取bean.xml文件，这里其实就是拥有所有配置里的对象的容器(按照我们自己实现的，这里其实就是一个Map)
             BeanFactory bf = new ClassPathXmlApplicationContext("bean.xml");
            // 这里使用无参的构造方法，使用注解，现在这个无参构造函数就退出舞台了
            // BeanFactory bf = new ClassPathXmlApplicationContext();
            // getBean(id)，通过 id 获取 对应的实例对象
            Object od = bf.getBean("dog");
            Animal dog = (Animal) od;
            dog.say();
            Object oc = bf.getBean("cat");
            Animal cat = (Animal) oc;
            cat.say();
            Object occ = bf.getBean("cat");
            Animal catt = (Animal) occ;
            // 用getBean获取两次，然后对比两个实例，结果是同一个
            System.out.println(cat==catt);
            // 去修改Bird类xml配置或者注解，加上scope="prototype"
            Object ob = bf.getBean("bird");
            Animal bird = (Animal) ob;
            bird.say();
            Object obb = bf.getBean("bird");
            Animal birdd = (Animal) obb;
            // 使用多例模式以后，就会发现两个对象是不一样的了
            System.out.println(bird==birdd);
        }
    }

这样就简单实现了多例模式，但是这有一个问题，就是存实例对象的容器Map的数据结构太复杂了，我们其实没有必要，写完以后我就直呼自己傻了，有反射干嘛不好好用呢，于是乎：

package TestIoc;
    import org.dom4j.Document;
    import org.dom4j.Element;
    import org.dom4j.io.SAXReader;
    import org.reflections.Reflections;
    
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Proxy;
    import java.util.*;
    // IOC实现，IOC容器，就是简单重写一个spring中的 ClassPathXmlApplicationContext 类
    /* xml配置文件整个流程： 读取xml配置文件，然后遍历所有的bean元素，获取到 id 和 类名， 然后通过反射Class.forName("类名").newInstance()创建一个实例对象，再将id和实例对象存到一个Map中 最后通过重写的getBean(id)方法，根据 id 返回实例对象 注解的整个流程： 自定义一个带参数的注解 根据自定义的注解在指定包范围内搜索出所有的类 再将注解的参数当作唯一标识，根据注解找到的类实例对象当作值，存入Map中 */
    public class ClassPathXmlApplicationContext implements BeanFactory{ 
        // 容器，用来存放实例对象
        private final Map<String, Object> container = new HashMap<>();
        // 多例模式的常量
        final String  NOSCOPES = "prototype";
        // 通过xml配置文件，创建实例对象，因为可以多个文件配置，所以我这里使用了...的形式
        // 不过下面的代码有一个问题，就是你要么选择xml配置，要么选择注解配置，如果两个一个用的话需要保证两边是一致的，不然因为代码运行的顺序，注解会将xml覆盖掉
        public ClassPathXmlApplicationContext(String... fileNames) throws Exception{ 
            // SAXReader是一个DOM解析器，能将路径中的XML文件解析为Document对象
            SAXReader sb = new SAXReader();
            // 因为String...接收的是一个数组，所以这里使用遍历
            for(String filename: fileNames){ 
                // class.getResource("/")会查找classpath根目录
                // 因为我是在一个spring的项目下弄了这个程序，所以classpath路径是target/classes/下，xml文件放在resources就可以了
                // read(xml的路径)转成Document类型对象
                Document doc = sb.read(ClassPathXmlApplicationContext.class.getResource("/"+filename));
                // getRootElement()获取根元素标签，根元素就是beans
                Element root = doc.getRootElement();
                // 从根元素下所有的bean元素
                List<Element> list =  root.elements("bean");
                // 便利所有bean标签元素
                for (Element bean : list) { 
                    // 获取每个bean元素
                    // 根据属性获取数据
                    String id = bean.attributeValue("id");
                    String clazz = bean.attributeValue("class");
                    String scope = bean.attributeValue("scope");
                    // 这里是通过反射修改类注解的值
                    Class<?> classes = Class.forName(clazz);
                    MyAnnontationBean anno = classes.getAnnotation(MyAnnontationBean.class);
                    InvocationHandler handler = Proxy.getInvocationHandler(anno);
                    Field field = handler.getClass().getDeclaredField("memberValues");
                    field.setAccessible(true);
                    Map<String,String> annoMap = (Map) field.get(handler);
                    if(scope!=null && scope.equals(NOSCOPES)){ 
                        // 如果读取到xml配置文件历史多例模式，就改写注解的值
                        annoMap.put("scope", NOSCOPES);
                    }
                    // 这里我简单粗暴一点，我都存入实例对象，但是在getBean()方法里，我会将多例的对象转成Class再重新生成对象
                    Object obj = classes.newInstance();
                    // 将实例对象加入容器中
                    container.put(id, obj);
                }
                // 查找classpathPackage标签，因为可能是多个所以使用list
                List<Element> packages =  root.elements("classpathPackage");
                // 遍历所有classpathPackage标签
                for (Element newpackage: packages) { 
                    // 查找classpathPackage标签的packagePath属性
                    String packagePath = newpackage.attributeValue("packagePath");
                    if(!packagePath.equals("")) { 
                        // 反射的指定范围，在这个包下面，包下面的子包都是包含的
                        // 其实这里不应该写死哪个包，也应该是一个配置文件读取
                        Reflections reflections = new Reflections(packagePath);
                        // 根据指定的注解获取所有的类
                        // getTypesAnnotatedWith()根据指定的注解搜索所有的类
                        Set<Class<?>> classes = reflections.getTypesAnnotatedWith(MyAnnontationBean.class);
                        // 遍历获取到的类
                        for (Class<?> type : classes) { 
                            // 获取注解的参数，就是相当于xml中的id
                            // getAnnotation()获取注解
                            MyAnnontationBean annon = type.getAnnotation(MyAnnontationBean.class);
                            // 注解的参数，就是唯一标识
                            // value()是自定义注解中的方法
                            String value = annon.value();
                            // 这里不需要判断是否存在是因为自定义注解中，我们给了默认值
                            String scope = annon.scope();
                            // 这里是通过反射修改类注解的值
                            InvocationHandler handler = Proxy.getInvocationHandler(annon);
                            Field field = handler.getClass().getDeclaredField("memberValues");
                            field.setAccessible(true);
                            Map<String, String> annoMap = (Map) field.get(handler);
                            // 如果是singleton就是单例，存进去创建好的实例
                            if (scope!=null && scope.equals(NOSCOPES)) { 
                                // 如果读取到xml配置文件历史多例模式，就改写注解的值
                                annoMap.put("scope", NOSCOPES);
                            }
                            // 这里我简单粗暴一点，我都存入实例对象，但是在getBean()方法里，我会将多例的对象转成Class再重新生成对象
                            Object obj = type.newInstance();
                            // 将id和object存入map中
                            container.put(value, obj);
                        }
                    }
                }
            }
        }
        @Override
        public Object getBean(String id) { 
            Object newobj = null;
            // 根据xml中bean的id找到对应的实例
            Object obj = container.get(id);
            // 将Object转成Class
            Class<?> clazz = obj.getClass();
            // 获取注解
            MyAnnontationBean annon = clazz.getAnnotation(MyAnnontationBean.class);
            // 获取注解参数
            String scope = annon.scope();
            String SCOPES = "singleton";
            if(scope.equals(SCOPES)){ 
                // 是单例直接返回原来存储的对象
                newobj = obj;
            }else{ 
                try { 
                    // 是多例就现在创建一个新对象
                    newobj = clazz.newInstance();
                } catch (InstantiationException e) { 
                    e.printStackTrace();
                } catch (IllegalAccessException e) { 
                    e.printStackTrace();
                }
            }
            // 返回对象
            return newobj;
        }
    }

#### Bean自动装配 ####

spring三种装配：  
1：xml装配  
2：注解装配  
3：自动装配

byName/byType自动装配：

class Animal{ 
        Bear bear;
        setBear(Bear newbear){ 
            this.bear = newbear;
        }
    }

<bean id="animal" class="service.Animal" autowire="byName"/>
    
    
    <bean id="animal" class="service.Animal" autowire="byType"/>
    
    
    <bean id="bear" class="dao.Bear"/>

使用注解实现自动装配：

先在xml配置文件中的beans标签下添加下面的内容：

<context:annotation-config/>

还是以上面的代码为例：

class Animal{ 
        // 在属性或者set方法上添加@Autowired这个注解就可以实现自动装配，其实使用@Autowired可以连set方法也不写，像是会自动给你生成一个set方法一样
        @Autowired
        Bear bear;
    }

<bean id="animal" class="service.Animal"/>
    <bean id="bear" class="dao.Bear"/>

// @Autowired 注解可以用参数，required = false 可以为空
    @Autowired(required = false)

// @Autowired是根据类型进行自动装配，所以xml中出现多个一样的类型就会报错，这时候@Autowired就可以搭配@Qualifier这个注解使用，用来指定bean的id
    @Autowired()
    @Qualifier(value = "bearl111")
    private Bear bear;

通过配合@Qualifier就可以指向id为bearl111的bean，当然如果指定了类型不一样的对象还是会报错的，对象类型必须一致

java的原生注解@Resource：

@Autowired是根据类型(子类)或者set方法set后面的单词(且首字母的大小写无关)，再到xml中通过id或者class寻找bean，  
但是@Resource是注解上的变量名或者类型必须一致，它先通过变量名对比id，找不到再通过类型寻找class，@Resource(name=“bear111”)也有一个参数name用来指定查询bean的id

class Animal{ 
        // 这里的类型和变量名必须在xml中存在，否则找不到
        // @Resource(name="bear111") 这样可以通过name去匹配xml的bean中的id
        @Resource
        Bear bear;
    }

### Spring注解 ###

<context:component-scan base-package="pojo"/>

#### 如何注入和装配 ####

@Component： 标注Spring管理的Bean，使用@Component注解在一个类上，表示将此类标记为Spring容器中的一个Bean，相当于丢给了IOC容器

*在上面我们自己实现的注解形式IOC，现在看一下，好像差不多，就是我们需要自己指定名字，它这里是自动用类名首字母小写*

原本我们写一个类，都需要去xml中在写一个bean，但是我们给类加上@Component，就不需要再去xml中配置，相当于自动生成，当然这个类必须在xml的context:component-scan指定扫描包下面

还有三个相关的注解：

*  dao层使用 @Repository
 *  service层使用 @Service
 *  controller层使用 @Controller

这三个都是和@Component一样的功能，都是将类交给Spring管理，装配bean

#### 自动装配 ####

@Autowired  
@Qualifier

这两个上面讲过了

#### 作用域 ####

@Scope(“prototype”)

默认还是单例，可以添加参数选择不同的作用域

*之前我们实现的注解的多例模式是放在一个注解里，而Spring是分开为不同的注解，整个Spring的源码将很多东西都分得很细很散，为得就是可以兼容前后版本，然后更加灵活*

// @Component 等价于 <bean id="testUser" class="pojo.TestUser">
    @Component
    @Scope("prototype")
    public class TestUser { 
        // @Value("xxx") 等价于 <property name="username" value="xxx">
        // @Value("xxx")也可用在set方法上，效果是一样的
        @Value("注解注入的nanme")
        public String username;
        // @Value("注解注入的nanme")
        // public void setUsername(String username) { 
            // this.username = username;
        // }
    }

xml和注解的对比：

*  xml适用场景多，维护方便（xml用来管理所有的bean，和复杂的属性注入）
 *  注解只能针对自己的类，维护复杂（注解负责简单的属性注入）

### 完全Java的方式配置Spring ###

JavaConfig配置方式，这是一种完全脱离xml配置文件的配置方式

流程：

1.  创建一个cofig配置类，使用@Configuration声明为配置类，@Bean通过set方法声明注册的类，返回是这个实例
2.  写一个类，使用@Component自动注册

目录结构：

*  configs
    
     *  TestConfig.java(配置类)
     *  TestConfigUser.java
     *  TestTeacher.java
 *  myTest
    
     *  SpringTest.java(测试类)

TestConfigUser.java：

// @Component 注册这个bean
    // 这里有一点，去掉@Component仍然是可以注册成功的
    @Component，我觉得配置类中的@Bean注解会去查找对应的类
    public class TestConfigUser { 
        @Value("myname")
        public String myname;
    }

TestTeacher.java：

// @Component 注册这个bean
    // 这里有一点，IDEA中，去掉@Component仍然是可以注册成功的
    @Component
    public class TestTeacher { 
        @Value("teacher")
        public String name;
    }

TestConfig.java：

// 声明是一个配置类
    @Configuration
    // @ComponentScan("configs") 扫描包的范围
    // @Import(TestConfig2.class) 导入其它配置类
    public class TestConfig { 
        // @Bean 通过方法注册一个bean，这里的返回值就Bean的类型，方法名就是bean的id
        @Bean
        TestConfigUser testConfigUser(){ 
            return new TestConfigUser();
        }
        // @Bean 可以指定名字，相当于bean的id
        @Bean("teacher")
        TestTeacher testTeacher(){ 
            return new TestTeacher();
        }
    }

SpringTest.java：

public class SpringTest { 
        @Test
        public void demo(){ 
            // 使用AnnotationConfigApplicationContext类，添加配置类
            ApplicationContext application = new AnnotationConfigApplicationContext(TestConfig.class);
            // 还是和之前xml配置一样，使用getBean()获取对象
            TestTeacher teacher = application.getBean("teacher", TestTeacher.class);
            System.out.println(teacher.name);
        }
    }