创建对象

基础知识:

  1. <!--
  2. 创建对象: 声明bean,告知spring容器创建哪些对象
  3. 一个bean标签表示一个对象
  4. id="对象名", 要求唯一
  5. class="完全限定名"
  6. 注:spring底层通过反射创建对象,不能写接口
  7. 相当于com.kkb.pojo.Team team1=new Team();
  8. 然后将创建的对象放入到spring容器的一个map中
  9. springMap.put(id, 对象)
  10. 例如:springMap.put("team1", new Team());
  11. -->
  1. <!--name标签用的少一些,但是里面的限定会少一些-->
  2. <!--singleton 马上创建(默认) 容器启动之后单例对象被创建了,而且容器中只有唯一的一个对象
  3. prototype 现用现去创建 多例对象 什么时候使用什么时候创建 -->
  4. <!--
  5. lazy-init:true/false 是否懒加载,针对单例对象,懒加载之后会现用现去创建
  6. -->
  7. <!--
  8. 生命周期相关:只用于单例对象singleton
  9. init-method:init, 对象创建完毕之后立即创建初始化方法
  10. destroy-method: spring容器调用销毁方法的时候执行的方法
  11. -->

测试用例:

Team.java

  1. package com.kkb.pojo;
  2. public class Team {
  3. private Integer id;
  4. private String name;
  5. private String location;
  6. public Team(){
  7. System.out.println("构造方法被执行");
  8. }
  9. public Team(Integer id, String name, String location) {
  10. this.id = id;
  11. this.name = name;
  12. this.location = location;
  13. System.out.println("带参数的构造方法被执行 "+id+" "+name+" "+location);
  14. }
  15. public void init(){
  16. System.out.println("team------init------");
  17. }
  18. public void destroy(){
  19. System.out.println("team------destroy------");
  20. }
  21. }

application.xml

  1. <bean id="team1" name="team1" class="com.kkb.pojo.Team" scope="singleton" lazy-init="true" init-method="init" destroy-method="destroy"> </bean>
  2. <bean id="team2" name="team2" class="com.kkb.pojo.Team" scope="prototype"> </bean>
  3. <!--获取非自定义对象,如日期-->
  4. <bean id="date1" class="java.util.Date"> </bean>
  1. <!--
  2. Spring容器创建对象的方式:
  3. 1、通过默认构造方法
  4. 2、通过带参数的构造方法
  5. 3、通过工厂方法
  6. -->

创建对象的三种方法

bean包

  1. package com.cq.pojo;
  2. public class Animal {
  3. private String type;
  4. private String variety;
  5. public Animal(){
  6. System.out.println("默认构造方法------被执行------");
  7. }
  8. public Animal(String type, String variety) {
  9. this.type = type;
  10. this.variety = variety;
  11. System.out.println("全参构造方法:------ "+"type: "+type+" variety: "+variety);
  12. }
  13. }

方式1:通过默认构造方法

src.main.resources.myApplication.xml

  1. <!-- 自定义对象 -->
  2. <bean id="cat" class="com.cq.pojo.Animal"></bean>
  3. <bean id="dog" class="com.cq.pojo.Animal"></bean>
  4. <!-- 非自定义对象 -->
  5. <bean id="date1" class="java.util.Date"></bean>

src.test.java.com.cq.test.AnimalTest.java

  1. @Test
  2. public void test01(){
  3. String applicationConfig = "myApplication.xml";
  4. ApplicationContext applicationContext = new ClassPathXmlApplicationContext(applicationConfig);
  5. Animal cat = (Animal)applicationContext.getBean("cat"); //强转
  6. System.out.println(cat);
  7. Animal dog = (Animal)applicationContext.getBean("dog");
  8. System.out.println(dog);
  9. int beanDefinitionCount = applicationContext.getBeanDefinitionCount(); //获取容器当中bean的数量
  10. System.out.println("容器当中元素的个数:"+beanDefinitionCount);
  11. String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
  12. System.out.println("容器当中的对象名称:");
  13. for(String a: beanDefinitionNames){
  14. System.out.println("\t"+a); //获取容器当中对象的名称
  15. }
  16. //获取非自定义对象
  17. Date date1 = (Date)applicationContext.getBean("date1");
  18. System.out.println("当前时间:"+date1);
  19. }

方法2:通过带参数的构造方法

2.1 name获取Animal类中的元素名称

src.main.resources.myApplication.xml

  1. <bean id="animal1" class="com.cq.pojo.Animal">
  2. <constructor-arg name="type" value="dog"/>
  3. <constructor-arg name="variety" value="哈士奇"/>
  4. </bean>

2.2 index获取下标(起始下标为0)

src.main.resources.myApplication.xml

  1. <bean id="animal2" class="com.cq.pojo.Animal">
  2. <constructor-arg index="0" value="dog"/>
  3. <constructor-arg index="1" value="哈士奇"/>
  4. </bean>

方法3:通过工厂方法

3.1 实例方法

  1. //实例方法
  2. public Animal instanceFun(){
  3. System.out.println("MyFactory------instanceFun------");
  4. return new Animal("cat", "加菲猫");
  5. }
  6. public static void main(String[] args) {
  7. MyFactory factory = new MyFactory();
  8. Animal animal2 = factory.instanceFun();
  9. }
  1. <!-- id可以随便起 -->
  2. <bean id="factory" class="com.cq.pojo.MyFactory"></bean>
  3. <bean id="instanceAnimal" factory-bean="factory" factory-method="instanceFun"></bean>

3.2 静态方法

  1. //静态方法
  2. public static Animal staticFun(){
  3. System.out.println("MyFactory------staticFun------");
  4. return new Animal("dog", "二哈");
  5. }
  6. public static void main(String[] args) {
  7. Animal animal1 = MyFactory.staticFun();
  8. }
  1. <bean id="staticAnimal" class="com.cq.pojo.MyFactory" factory-method="staticFun"></bean>