Spring(bean为什么需要依赖注入)

Spring,bean为什么需要依赖注入,恰卡网带你了解更多相关信息。

目录
  • 具体步骤:
    • 样例1:
    • 样例2:
  • Spring单例模式和原型模式
    • 一、单例模式
    • 二、原型模式
    • 思考 为什么需要依赖注入
  • 总结

    具体步骤:

    1.创建一个maven项目 spring-day1-constructor

    2.导入依赖

        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <!--这里是java 版本号-->
            <maven.compiler.source>11</maven.compiler.source>
            <maven.compiler.target>11</maven.compiler.target>
            <!--这里是方便版本控制-->
            <spring.version>5.3.1</spring.version>
            <lombok.version>1.18.20</lombok.version>
            <junit.version>4.12</junit.version>
        </properties>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
        </dependencies>
    

    3.工程项目结构

    样例1:

    1.创建一个Student类

    public class Student {
        private Long number;
        private String name;
        private String school;
        public void setNumber(Long number) {
            this.number = number;
        }
        public void setName(String name) {
            this.name = name;
        }
        public void setSchool(String school) {
            this.school = school;
        }
        public Student() {
        }
        public Student(Long number, String name, String school) {
            this.number = number;
            this.name = name;
            this.school = school;
        }
        @Override
        public String toString() {
            return "Student{" +
                    "number=" + number +
                    ", name='" + name + '\'' +
                    ", school='" + school + '\'' +
                    '}';
        }
    }
    

    写一个配置文件

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
        <!--这里是根据构造函数内的顺序往里面注入-->
        <bean id="s1" class="com.crush.pojo.Student">
           <constructor-arg index="0" value="12"/>
            <constructor-arg index="1" value="wyh"/>
            <constructor-arg index="2" value="北大"/>
        </bean>
        <!--这里是根据构造函数中的 类型来进行注入 -->
        <bean id="s2" class="com.crush.pojo.Student">
            <constructor-arg type="java.lang.Long" value="123"/>
            <constructor-arg type="java.lang.String" value="crush"/>
            <constructor-arg type="java.lang.String" value="浙江大学"/>
        </bean>
    </beans>
    

    3.测试

       @org.junit.Test
        public void testStudent(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
            Student student = applicationContext.getBean("s2", Student.class);
            System.out.println(student);
        }
    

    样例2:

    1.创建Teacher类

    public class Teacher {
        private String name;
        private String school;
        private List<Student> studentList;
        private Map<String,String> map;
        private Set<String> set;
        public Teacher(String name, String school, List<Student> studentList, Map<String, String> map, Set<String> set) {
            this.name = name;
            this.school = school;
            this.studentList = studentList;
            this.map = map;
            this.set = set;
        }
        @Override
        public String toString() {
            return "Teacher{" +
                    "name='" + name + '\'' +
                    ", school='" + school + '\'' +
                    ", studentList=" + studentList +
                    ", map=" + map +
                    ", set=" + set +
                    '}';
        }
    }public class Teacher {
        private String name;
        private String school;
        private List<Student> studentList;
        private Map<String,String> map;
        private Set<String> set;
        public Teacher(String name, String school, List<Student> studentList, Map<String, String> map, Set<String> set) {
            this.name = name;
            this.school = school;
            this.studentList = studentList;
            this.map = map;
            this.set = set;
        }
        @Override
        public String toString() {
            return "Teacher{" +
                    "name='" + name + '\'' +
                    ", school='" + school + '\'' +
                    ", studentList=" + studentList +
                    ", map=" + map +
                    ", set=" + set +
                    '}';
        }
    }
    

    2.beans.xml

    <bean id="teacher" class="com.crush.pojo.Teacher">
        <constructor-arg index="0" value="xxx"/>
        <constructor-arg index="1" value="北京大学"/>
        <constructor-arg index="2" >
            <list>
                <ref bean="s1"/>
                <ref bean="s2"/>
            </list>
        </constructor-arg>
        <constructor-arg index="3">
            <map>
                <entry key="k1" value="xiaowang"/>
            </map>
        </constructor-arg>
        <constructor-arg index="4">
            <set>
                <value>1</value>
                <value>2</value>
            </set>
        </constructor-arg>
    </bean>
    

    3.测试

        @org.junit.Test
        public void testTeacher(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
            Teacher teacher  = applicationContext.getBean("teacher", Teacher.class);
            System.out.println(teacher);
        }
    

    Spring单例模式和原型模式

    一、单例模式

    Spring默认是单例模式的。

    以Student的那个样例1 为例。 scope=“singleton” 加上这么一个设置 当然默认也是它。

    bean id="s1" class="com.crush.pojo.Student" scope="singleton">
        <constructor-arg index="0" value="12"/>
        <constructor-arg index="1" value="wyh"/>
        <constructor-arg index="2" value="北大"/>
    </bean>
    

    这个时候我们来进行测试

        @org.junit.Test
        public void testStudent(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
            Student student1 = applicationContext.getBean("s1", Student.class);
            Student student2 = applicationContext.getBean("s1", Student.class);
            // 并且如果我们对其中一个做了修改 ,其余也会跟着一起被修改
            // 可以看到我们只修改了一个
            student1.setSchool("梦中的学校");
            System.out.println(student1);
            System.out.println(student2);
            System.out.println(student1==student2);
        }
    

    二、原型模式

    我们还是以**Student来做例子讲解 ** 注意:我们把原来设置改成了 scope=“prototype” 也就是原型模式

    <!--这里是根据构造函数中的 类型来进行注入 -->
    <bean id="s2" class="com.crush.pojo.Student" scope="prototype">
        <constructor-arg type="java.lang.Long" value="123"/>
        <constructor-arg type="java.lang.String" value="crush"/>
        <constructor-arg type="java.lang.String" value="浙江大学"/>
    </bean>
    

    接着测试

        @org.junit.Test
        public void testStudent(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
            Student student1 = applicationContext.getBean("s2", Student.class);
            Student student2 = applicationContext.getBean("s2", Student.class);
            // 并且如果我们对其中一个做了修改 ,其余也会跟着一起被修改
            // 可以看到我们只修改了一个
            student1.setSchool("梦中的学校");
            System.out.println(student1);
            System.out.println(student2);
            System.out.println(student1==student2);
        }
    

    思考 为什么需要依赖注入

    为什么我们以前用一个对象 new一下就好了,但用了Spring 之后,反而还需要写

    这样一段代码再去获取勒?明明感觉更麻烦啦丫?用这个又有什么样的好处呢?

    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
    Student student1 = applicationContext.getBean("s2", Student.class);
    

    总结

    本篇文章就到这里了,希望能给你带来帮助,也希望您能够多多关注趣讯吧的更多内容!

    发布于 2021-07-16 18:40:20
    收藏
    分享
    海报
    0 条评论
    177
    上一篇:Spring(Cloud,Config,使用本地配置文件方式) 下一篇:Spring(Cloud,如何保证微服务内安全)
    目录

      0 条评论

      本站已关闭游客评论,请登录或者注册后再评论吧~

      忘记密码?

      图形验证码