• Spring之bean对象

    目录

    一、了解Bean

    二、Bean的生命周期

    三、Bean的应用

    单例模式

    多例模式

    单例模式与多例模式优劣势：

    一、了解javaBean

     什么是javaBean对象?

    在Spring 中，构成应用程序主干并由Spring ioc容器管理的对象称为bean。bean是一个由Spring ioc容器实例化、组装和管理的对象。

    我们总结如下：
    1.bean是对象，一个或者多个不限定
    2.bean由Spring中一个叫ioC的东西管理

    二、Bean的生命周期

    Spring Bean的生命周期：
    1）通过XML、Java annotation（注解）以及Java Configuration（配置类）
    等方式加载Spring Bean

    2）BeanDefinitionReader：解析Bean的定义。在Spring容器启动过程中，
    会将Bean解析成Spring内部的BeanDefinition结构；
    理解为：将spring.xml中的标签转换成BeanDefinition结构
    有点类似于XML解析

    3）BeanDefinition：包含了很多属性和方法。例如：id、class（类名）、
    scope、ref（依赖的bean）等等。其实就是将bean（例如）的定义信息
    存储到这个对应BeanDefinition相应的属性中

    例如：
    -----> BeanDefinition(id/class/scope)

    4）BeanFactoryPostProcessor：是Spring容器功能的扩展接口。

    注意：
    1）BeanFactoryPostProcessor在spring容器加载完BeanDefinition之后，
    在bean实例化之前执行的
    2）对bean元数据（BeanDefinition）进行加工处理，也就是BeanDefinition
    属性填充、修改等操作

    5）BeanFactory：bean工厂。它按照我们的要求生产我们需要的各种各样的bean。


    6）Aware感知接口：在实际开发中，经常需要用到Spring容器本身的功能资源
    例如：BeanNameAware、ApplicationContextAware等等
    BeanDefinition 实现了 BeanNameAware、ApplicationContextAware

    7）BeanPostProcessor：后置处理器。在Bean对象实例化和引入注入完毕后，
    在显示调用初始化方法的前后添加自定义的逻辑。（类似于AOP的绕环通知）

    前提条件：如果检测到Bean对象实现了BeanPostProcessor后置处理器才会执行
    Before和After方法
    BeanPostProcessor
    1）Before
    2）调用初始化Bean（InitializingBean和init-method，Bean的初始化才算完成）
    3）After

    完成了Bean的创建工作

    8）destory：销毁
     

    如图

    三、Bean的应用

    测试代码

    package beanLife;

    public class Demo1 {
        
            public static void main(String[] args) {
                Person p=new Person();
             
                p.setSex("女");//实例化后修改属性
           System.out.println(p.getSex());
              
            }
        
        

    }
     class Person{
         private String name;
         private int age;
         private String sex;
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public String getSex() {
            return sex;
        }
        public void setSex(String sex) {
            this.sex = sex;
        }
         
        public Person(String name, int age, String sex) {
            this.name = name;
            this.age = age;
            this.sex = sex;
        }
        @Override
        public String toString() {
            return "Person [name=" + name + ", age=" + age + ", sex=" + sex + "]";
        }
    //    
         public Person() {
             this.init();
             this.name="小三";
             this.age=23;
             this.sex="未知";
             
         }
         public void init() {
             
         }
         
     }
     

    图片1

    改进后

    package beanLife;

    public class Demo1 {
        
            public static void main(String[] args) {
    //            Person p=new Person();
    //            Person p1=new Person();
    //            Person p2=new Person();
    //            Person p3=new Person();
                Person p0=Person.newInstance();
                Person p1=Person.newInstance();
                Person p2=Person.newInstance();
                Person p3=Person.newInstance();
    //            p.setSex("女");//实例化后修改属性
                System.out.println(p0);
                System.out.println(p1);
                System.out.println(p2);
                System.out.println(p3);
            }
        
        

    }
     class Person{
        
         private Person() {
             
         }
         private final static Person p=new Person();
         
         public static Person newInstance() {
             return p;
         }
         
    //     public void init() {
    //         
    //     }
         
     }
     

    图片2

    单例模式

     单例模式的使用原因：

    举个例子1

    一个类如果被使用了100次，如果这个项目一共有1万个类，那么Spring上下文要创建多少个对象？

    答案：一共需要一百万个对象

     如下面代码

    package beanLife;

    public class Demo1 {
        
            public static void main(String[] args) {
    //            Person p=new Person();
    //            Person p1=new Person();
    //            Person p2=new Person();
    //            Person p3=new Person();
                Person p0=Person.newInstance();
                Person p1=Person.newInstance();
                Person p2=Person.newInstance();
                Person p3=Person.newInstance();
    //            p.setSex("女");//实例化后修改属性
                System.out.println(p0);
                System.out.println(p1);
                System.out.println(p2);
                System.out.println(p3);
            }   

    }
     class Person{
        
         private Person() {
             
         }
         private final static Person p=new Person();
         
         public static Person newInstance() {
             return p;
         }
     }
     

     图片--对象

    多例模式

    举个例子2

    一个类在100个地方使用，使得有的都是同一个对象，这个项目有1w个类，请问Spring上下文要创建多少个对象？

    答案：1w个对象

    单例模式与多例模式优劣势：

     以生活为例

    孩子A和孩子B 

    给两个孩子买同一个玩具 和各自买不同的玩具，其中的优缺点为；

    买一种玩具，买两份（多例模式）：

    缺点：种类单一，成本大；优点：数量多，孩子容易满足，减少不必要的争夺

    买不同的玩具，各买一份（单例模式）

     缺点：玩具被前者使用过，容易造成污染，孩子容易产生不公平心理，优点：玩具种类多

    代码：

    1. package beanLife;
    2.  
    3. import java.util.List;
    4.  
    5.  
    6. import com.zking.biz.UserBiz;
    7. import impl.UserBizImpl1;
    8. import impl.UserBizImpl2;
    9.  
    10. /**验证单例模式与多例模式的区别
    11.  * @author lucy
    12.  *
    13.  */
    14. public class ParamAction {
    15. 	private int age;
    16. 	private String name;
    17. 	private List hobby;
    18. 	private int num = 1;//变量
    19. 	// private UserBiz userBiz = new UserBizImpl1();
    20.  
    21. 	public ParamAction() {
    22. 		super();
    23. 	}
    24.  
    25. 	public ParamAction(int age, String name, List hobby) {
    26. 		super();
    27. 		this.age = age;
    28. 		this.name = name;
    29. 		this.hobby = hobby;
    30. 	}
    31.  
    32. 	public void execute() {
    33. 		// userBiz.upload();
    34. 		// userBiz = new UserBizImpl2();
    35. 		System.out.println("this.num=" + this.num++);
    36. 		System.out.println(this.name);
    37. 		System.out.println(this.age);
    38. 		System.out.println(this.hobby);
    39. 	}
    40. }

    1. package beanLife;
    2.  
    3. /**
    4.  * @author lucy
    5.  *
    6.  */
    7. public class InstanceFactory {
    8. 	public void init() {
    9. 		System.out.println("初始化方法");
    10. 	}
    11.  
    12. 	public void destroy() {
    13. 		System.out.println("销毁方法");
    14. 	}
    15.  
    16. 	public void service() {
    17. 		System.out.println("业务方法");
    18. 	}
    19. }

    测试

    package beanLife;

    import org.junit.Test;
    import org.springframework.beans.factory.BeanFactory;
    import org.springframework.beans.factory.xml.XmlBeanFactory;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.core.io.ClassPathResource;
    import org.springframework.core.io.Resource;

    /*
     * spring    bean的生命週期
     * spring    bean的單例多例
     */
    public class Demo2 {
        // 体现单例与多例的区别
        @Test
        public void test1() {
            ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-context.xml");
    //        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-context.xml");
            ParamAction p1 = (ParamAction) applicationContext.getBean("paramAction");
            ParamAction p2 = (ParamAction) applicationContext.getBean("paramAction");
            // System.out.println(p1==p2);
            p1.execute();
            p2.execute();
            
    //        单例时，容器销毁instanceFactory对象也销毁；多例时，容器销毁对象不一定销毁；
            applicationContext.close();
        }

        // 体现单例与多例的初始化的时间点 instanceFactory
        @Test
        public void test2() {
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-context.xml");
        }

        // BeanFactory会初始化bean对象，但会根据不同的实现子类采取不同的初始化方式
        // 默认情况下bean的初始化，单例模式立马会执行，但是此时XmlBeanFactory作为子类，单例模式下容器创建，bean依赖没有初始化，只有要获取使用bean对象才进行初始化
        @Test
        public void test3() {
            // ClassPathXmlApplicationContext applicationContext = new
            // ClassPathXmlApplicationContext("/spring-context.xml");

            Resource resource = new ClassPathResource("/spring-context.xml");
            BeanFactory beanFactory = new XmlBeanFactory(resource);
    //        InstanceFactory i1 = (InstanceFactory) beanFactory.getBean("instanceFactory");
            
        }

    }
     

    多例举例


        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
            
        
        scope="prototype" > 
        
        
        
        
        
        
        
        rap
        画画
        看沉香
        
        
        
        
        
        
        
        
        
        
        
        rap
        画画
        看沉香
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
            com.zking.aop.biz.BookBiz
        
        
        
        
        
            myBefore
             myAfter
            
            myMethod
            myThrow
        
        
        
        
        
            
            
            
                
                    抽烟
                    烫头
                    大保健
                
            
        

                 scope="prototype" init-method="init" destroy-method="destroy">
                
        
        

     

     

     单例举例


        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
            
        
        scope="singleton">
        
        
        
        
        
        
        
        rap
        画画
        看沉香
        
        
        
        
        
        
        
        
        
        
        
        rap
        画画
        看沉香
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
            com.zking.aop.biz.BookBiz
        
        
        
        
        
            myBefore
             myAfter
            
            myMethod
            myThrow
        
        
        
        
        
            
            
            
                
                    抽烟
                    烫头
                    大保健
                
            
        

                 scope="prototype" init-method="init" destroy-method="destroy">
                
        
        

     

    【总结：】

    两者区别、特点：

    单例模式下javabean的生命周期：

    “容器对象生，容器对象死”

     多例模式下javabean的生命周期；

    “使用时对象生，死亡跟着jvm垃圾回收机制走”

    特点：bean的初始化时间点，除了与bena管理模式（单例、多例） 有关，还跟BeanFactory的子类有关

  • 相关阅读:
    【Effective Python】读书笔记-06元类与属性
    java毕业设计巢院小区疫情管控系统Mybatis+系统+数据库+调试部署
    【Linux】之Centos7卸载KVM虚拟化服务
    特殊符号: && 和 | | 和 ?? 和 ？作用详解
    「PAT乙级真题解析」Basic Level 1107 老鼠爱大米 (问题分析+完整步骤+伪代码描述+提交通过代码)
    【算法】莫队
    c 几种父进程主动终止子进程的方法
    shell运行原理
    debian安装MySQL
    代码随想录算法训练营第四十六天|动态规划|139.单词拆分、关于多重背包，你该了解这些！ 、背包问题总结篇！
  • 原文地址：https://blog.csdn.net/qq_66924116/article/details/126234729