再来看一下构造函数注入,构造函数注入呢,我还是在这个配置文件里演示,构造函数了,我分割一下,
华丽的分割线下方,来演示一下构造函数注入,构造函数注入,现在不走set方法了,我是不是要走构造,
那走构造的前提,你得有构造,所以先的准备一个带有参数的构造,选择生成构造,这个的话咱们这样,
挑一个name,挑一个car,这样出一个代表,一个是值类型代表,一个是对象类型代表,那接下来看一下,
走这个构造,完成对象的创建,为了标识,我把构造函数打印一下,打印出来了,能看到走的他,配置一个还是
bean元素,然后name,class,然后看好,我要走构造注入的话,下面这不一样了,要用constructor-arg,Spring连
元素的起名都是这么清晰,你看constructor是不是构造,arg就是arguments参数,叫构造参数,咱们这种情况可以使用
到name属性,value属性,以及咱们的name属性,ref属性,我这么一写你就明白啥意思了,因为咱们的声明构造是不是两个参数,
所以咱们添加两个构造,参数的意思,添加两个参数,然后第一个参数你看,第一个参数的名字叫name,这里是不是给他一个值,
值的名字,比如咱们叫jerry,咱们第二个属性名是不是叫car,复制变量名到这儿来,ref表示对象的引用,那咱们是不是要把上面的车搞下来,
这里是User,这个构造函数写在User里面,这是咱们创建一个新的User对象,咱们新的User对象是构造函数,声明两个参数的构造函数,
一个name,一个car,这里咱们应该叫user2
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.2.xsd ">
<!-- set方式注入 -->
<bean name="user" class="com.learn.bean.User">
<!-- 为User对象中名为name的属性注入tom作为值 -->
<property name="name" value="tom"></property>
<property name="age" value="18"></property>
<!-- 为car属性注入下方配置的car对象 -->
<property name="car" ref="car"></property>
</bean>
<!-- 将car对象配置到容器中 -->
<bean name="car" class="com.learn.bean.Car">
<property name="name" value="兰博基尼"></property>
<property name="color" value="黄色"></property>
</bean>
<!-- ============================================================= -->
<!-- 构造函数注入 -->
<bean name="user2" class="com.learn.bean.User">
<constructor-arg name="name" value="jerry"></constructor-arg>
<constructor-arg name="car" ref="car"></constructor-arg>
</bean>
</beans>
然后把测试方法复制,然后这个叫user2,那怎么证明他走了构造呢,这会再执行一下,走的是不是构造
@Test
public void fun2() {
/**
* 1.创建容器
*/
ApplicationContext ac = new ClassPathXmlApplicationContext("com/learn/c_injection/applicationContext.xml");
/**
* 2.向容器要"user"对象
*/
User u = (User)ac.getBean("user2");
/**
* 打印user对象
*/
System.out.println(u);
}
User空参构造方法
User(String name, Car car)
User [name=jerry, age=null, car=Car [name=兰博基尼, color=黄色]]
这个是不是对构造器打印,再看这个jerry,是不是有值,后面这车是不是还是黄色的车,这个age咱们是没有注入,
构造注入学到这个程度,就够了吗,不够,这怎能够了呢,看好啊,假设现在构造函数不止这两个,还有第三个呢,
第三个构造呢,我是Car在前,name在后,你看有问题吗,打印的时候Car在前面name在后,你敢说这两个是一个构造吗,
显然不是吧,是不是有可能咱们真正做的时候,构造里面的业务逻辑是不是一样的,那第二个方法你看,好像这两个构造
函数,从配置上来讲,都有一个构造函数的参数叫name,都有一个叫car,只是顺序不同而已
package com.learn.bean;
/**
* @author Leon.Sun
*/
public class User {
public User() {
System.out.println("User空参构造方法");
}
private String name;
private Integer age;
private Car car;
public User(String name, Car car) {
System.out.println("User(String name, Car car)");
this.name = name;
this.car = car;
}
public User(Car car, String name) {
System.out.println("User(Car car, String name)");
this.name = name;
this.car = car;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public void init() {
System.out.println("我是初始化方法!");
}
public void destory() {
System.out.println("我是销毁方法!");
}
public Car getCar() {
return car;
}
public void setCar(Car car) {
this.car = car;
}
@Override
public String toString() {
return "User [name=" + name + ", age=" + age + ", car=" + car + "]";
}
}
@Test
public void fun2() {
/**
* 1.创建容器
*/
ApplicationContext ac = new ClassPathXmlApplicationContext("com/learn/c_injection/applicationContext.xml");
/**
* 2.向容器要"user"对象
*/
User u = (User)ac.getBean("user2");
/**
* 打印user对象
*/
System.out.println(u);
}
User空参构造方法
User(Car car, String name)
User [name=jerry, age=null, car=Car [name=兰博基尼, color=黄色]]
现在的话走哪个不重要,他走的是Car在前边,他永远走的Car在前面,那你怎么指定name在前面呢,
介绍另外一个参数,叫做index,你看到名字就知道是索引,刚才Car一直在前面,当我想走name在前面,
写一个0,下面要写的话你就写index等于1,name是参数第0个的
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.2.xsd ">
<!-- set方式注入 -->
<bean name="user" class="com.learn.bean.User">
<!-- 为User对象中名为name的属性注入tom作为值 -->
<property name="name" value="tom"></property>
<property name="age" value="18"></property>
<!-- 为car属性注入下方配置的car对象 -->
<property name="car" ref="car"></property>
</bean>
<!-- 将car对象配置到容器中 -->
<bean name="car" class="com.learn.bean.Car">
<property name="name" value="兰博基尼"></property>
<property name="color" value="黄色"></property>
</bean>
<!-- ============================================================= -->
<!-- 构造函数注入 -->
<bean name="user2" class="com.learn.bean.User">
<constructor-arg name="name" value="jerry" index="0"></constructor-arg>
<constructor-arg name="car" ref="car" index="1"></constructor-arg>
</bean>
</beans>
@Test
public void fun2() {
/**
* 1.创建容器
*/
ApplicationContext ac = new ClassPathXmlApplicationContext("com/learn/c_injection/applicationContext.xml");
/**
* 2.向容器要"user"对象
*/
User u = (User)ac.getBean("user2");
/**
* 打印user对象
*/
System.out.println(u);
}
这个时候再执行一下Demo,是不是name在前面,看明白啥意思不,那构造函数,那咱们学到这一步,
还差啥呢,还差什么呢,我这里又有一个构造,这个构造呢,name在前,但是呢,第一个参数虽然是name,
但是类型是Integer,是一个数字,咱们加一个字符串就是String了,你不要管我业务上的意义,那你看我现在
要走,我现在想name在第一个,car在第二个,这个构造函数,并且这个类型是Integer类型的,那你看,咱们这个配置
是不是又有两个符合了
package com.learn.bean;
/**
* @author Leon.Sun
*/
public class User {
public User() {
System.out.println("User空参构造方法");
}
private String name;
private Integer age;
private Car car;
public User(String name, Car car) {
System.out.println("User(String name, Car car)");
this.name = name;
this.car = car;
}
public User(Car car, String name) {
System.out.println("User(Car car, String name)");
this.name = name;
this.car = car;
}
public User(Integer name, Car car) {
System.out.println("User(Integer name, Car car)");
this.name = name + "";
this.car = car;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public void init() {
System.out.println("我是初始化方法!");
}
public void destory() {
System.out.println("我是销毁方法!");
}
public Car getCar() {
return car;
}
public void setCar(Car car) {
this.car = car;
}
@Override
public String toString() {
return "User [name=" + name + ", age=" + age + ", car=" + car + "]";
}
}
第一个参数名为name的,这是不是有两,是不是都符合,那这种情况下,需要怎么指定,最后有一个属性
type,type这里的话,第一个是Integer类型的,那你就把Integer的完整类名复制,知道啥意思不,这就表示
我要走第一个参数名为name,并且类型是Integer类型的,当然这块的话你得给他整成数字,等下会报错,因为
这里传参必须是Integer,但是你这里不是Integer,再给他来一个999
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.2.xsd ">
<!-- set方式注入 -->
<bean name="user" class="com.learn.bean.User">
<!-- 为User对象中名为name的属性注入tom作为值 -->
<property name="name" value="tom"></property>
<property name="age" value="18"></property>
<!-- 为car属性注入下方配置的car对象 -->
<property name="car" ref="car"></property>
</bean>
<!-- 将car对象配置到容器中 -->
<bean name="car" class="com.learn.bean.Car">
<property name="name" value="兰博基尼"></property>
<property name="color" value="黄色"></property>
</bean>
<!-- ============================================================= -->
<!-- 构造函数注入 -->
<bean name="user2" class="com.learn.bean.User">
<constructor-arg name="name" value="999" index="0" type="java.lang.Integer"></constructor-arg>
<constructor-arg name="car" ref="car" index="1"></constructor-arg>
</bean>
</beans>
@Test
public void fun2() {
/**
* 1.创建容器
*/
ApplicationContext ac = new ClassPathXmlApplicationContext("com/learn/c_injection/applicationContext.xml");
/**
* 2.向容器要"user"对象
*/
User u = (User)ac.getBean("user2");
/**
* 打印user对象
*/
System.out.println(u);
}
User空参构造方法
User(Integer name, Car car)
User [name=999, age=null, car=Car [name=兰博基尼, color=黄色]]
这回再来执行一下,是不是走的Integer这个,名字就叫999,有了这三个属性,分别是index,type,name,
这三个属性,加一起就可以定位到任何一个构造了,任何一个再复杂的构造,有这三个属性都可以定位的,
这就是构造函数注入,咱们再简单写一下,name属性指定构造函数的参数名,然后index属性,指定构造函数的
参数索引,他所在的索引,然后第三个type是指定什么,构造函数的参数类型,那这样的话,构造函数注入就给
演示完了,就这么多
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.2.xsd ">
<!-- set方式注入 -->
<bean name="user" class="com.learn.bean.User">
<!-- 为User对象中名为name的属性注入tom作为值 -->
<property name="name" value="tom"></property>
<property name="age" value="18"></property>
<!-- 为car属性注入下方配置的car对象 -->
<property name="car" ref="car"></property>
</bean>
<!-- 将car对象配置到容器中 -->
<bean name="car" class="com.learn.bean.Car">
<property name="name" value="兰博基尼"></property>
<property name="color" value="黄色"></property>
</bean>
<!-- ============================================================= -->
<!-- 构造函数注入 -->
<bean name="user2" class="com.learn.bean.User">
<!-- name属性:构造函数的参数名 -->
<!-- index属性:构造函数的参数索引 -->
<!-- type属性:构造函数的参数类型 -->
<constructor-arg name="name" value="999" index="0" type="java.lang.Integer"></constructor-arg>
<constructor-arg name="car" ref="car" index="1"></constructor-arg>
</bean>
</beans>
269
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
