spring之对象创建和实例化

最新推荐文章于 2021-01-12 14:55:24 发布

七仔-

最新推荐文章于 2021-01-12 14:55:24 发布

阅读量512

点赞数

分类专栏： spring

spring 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

Spring中四种实例化bean的方式

本文主要介绍四种实例化bean的方式(注入方式) 或者叫依赖对象实例化的四种方式。上面的程序,创建bean 对象,用的是什么方法 ,用的是构造函数的方式 (Spring 可以在构造函数私有化的情况下把类对象创建出来)

常用的创建方式有以下四种：

1) setter 方法

2) 构造函数

3) 静态工厂

4) 实例工厂

一、用 setter 方式

public interface IUserDao {
                void addUser();
                void delUser();
                void updateUser();
            }
            
            public class UserDaoImpl implements IUserDao {
                public void addUser() {
                    System.out.println("addUser方法被调用了");
                }        
                public void delUser() {
                    System.out.println("delUser方法被调用了");
                }        
                public void updateUser() {
                    System.out.println("updateUser方法被调用了");
                }
            }
            
            public class UserAction {
                    private IUserDao dao; //dao是一个依赖对象,要由springg进行管理,要生成 get set 方法
                            public void execute(){
                            dao.addUser();
                            dao.updateUser();
                            dao.delUser();
                    }
                }

//配置文件
<bean name="userAction_name" class="cat.action.UserAction" >
<property name="dao" ref="userDao_name" />  //引用的是下面的名称
</bean>    
<bean name="userDao_name" class="cat.dao.UserDaoImpl" />

 //测试
ClassPathXmlApplicationContext ctx=new ClassPathXmlApplicationContext("beans.xml");
UserAction action=(UserAction)ctx.getBean("userAction_name");
action.execute();

二、构造函数

public class UserAction {
       //public UserAction(){} 可以保保留一个无参的构造函数
                
       //这是几个依赖对象,不用生成get set方法了
       private UserInfo user;
       private String school;
       private IUserDao dao;     
            
       //希望Spring 由构造函数注入依赖对象
       public UserAction(IUserDao dao,UserInfo user,String school){
              this.dao=dao;
              this.school=school;
              this.user=user;
              }
                
            
       public void execute(){
              dao.addUser();
              dao.updateUser();
              dao.delUser();
                    
              System.out.println(user);
              System.out.println(school);
}

//配置文件
<bean name="userInfo_name" class="cat.beans.UserInfo" >
      <property name="id" value="1" />
      <property name="userName" value="周周" />
      <property name="password" value="123" />
      <property name="note" value="这是备注" />
</bean>
                    
<bean name="userAction_name" class="cat.action.UserAction" >
      <constructor-arg ref="userDao_name" />
      <constructor-arg ref="userInfo_name" />
      <constructor-arg value="哈尔滨师范大学" />
</bean>
            
/*
也可以指定 索引和 type 属性 , 索引和type 都可以不指定
<bean name="userAction_name" class="cat.action.UserAction" >
<constructor-arg index="0" ref="userDao_name" type="cat.dao.IUserDao" />  如果是接口,就不能指定是实现类的类型
<constructor-arg index="1" ref="userInfo_name" type="cat.beans.UserInfo" />
<constructor-arg index="2" value="哈尔滨师范大学"  />
</bean>
*/
                
<bean name="userDao_name" class="cat.dao.UserDaoImpl" />

//测试
ClassPathXmlApplicationContext ctx=new ClassPathXmlApplicationContext("beans.xml");
UserAction action=(UserAction)ctx.getBean("userAction_name");
action.execute();

三、静态工厂方式

//工厂,用来生成dao的实现类
public class UserDaoFactory {
public static IUserDao createUserDaoInstance(){
       return new UserDaoOracleImpl();
       }
}

           
public class UserAction {
       private IUserDao dao;//使用工厂方式注值,也要生成set方法
       public void execute(){
              dao.addUser();
              dao.updateUser();
              dao.delUser();
}
                

public void setDao(IUserDao dao) {
              this.dao = dao;
              }    
}

//配置文件 
<bean name="userAction_name" class="cat.action.UserAction" >
<property name="dao"  ref="userDao_name" />
</bean>
              
<bean name="userDao_name" class="cat.dao.UserDaoFactory" factory-method="createUserDaoInstance" />

//测试
ClassPathXmlApplicationContext ctx=new ClassPathXmlApplicationContext("beans.xml");
UserAction action=(UserAction)ctx.getBean("userAction_name");
action.execute();

四、实例工厂

//工厂 =>
public class UserDaoFactory {
//这个方法不是静态的
public  IUserDao createUserDaoInstance(){
        return new UserDaoOracleImpl();
        }
}

//配置文件 
<bean name="userAction_name" class="cat.action.UserAction" >
<property name="dao"  ref="userDao_name" />
</bean>
              
<bean  name="userDaoFactory_name" class="cat.dao.UserDaoFactory" />
<bean name="userDao_name" factory-bean="userDaoFactory_name" factory-method="createUserDaoInstance" />

容器创建bean

spring容器创建对象的3种方式(bean的实例化)
1，调用默认的构造函数(默认)
1）指定bean的class属性
2）class需要一个默认的空构造器
<bean id="helloWorld" class="com.jxn.HelloWorld" />
得到实例对象：HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld");
2，使用静态工厂方法
1）指定class属性外
2）通过factory-method属性来指定创建bean实例的静态工厂方法
<bean id="helloWorld" class="com.jxn.HelloWorldFactory" factory-method="createInstance"></bean>
注：相当于调用了 HelloWorldFactory.createInstance();
public class HelloWorldFactory {
public static HelloWorld createInstance(){
return new HelloWorld();
}
}
得到实例对象：HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld");
3，使用实例工厂方法
1）定义一个工厂类
2）通过factory-bean属性指定工厂类，通过factory-method属性指定该工厂类的非静态工厂方法
<bean id="helloWorldFactory" class="com.jxn.HelloWorldFactory" />
<bean id="HelloWorld" factory-bean="helloWorldFactory" factory-method="createInstance" />
注：相当于调用了 new HelloWorldFactory.createInstance();
public class HelloWorldFactory {
public HelloWorld createInstance(){
return new HelloWorld();
}
}
得到实例对象：HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld");
注：spring调用工厂方法，在该工厂方法中，由程序员来创建对象。