您的位置:首页 > 编程语言 > Java开发

spring注入,构造方法注入

2020-01-15 11:53 106 查看

基于maven的pom.xml

<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>5.5.2</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<version>5.5.2</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-params</artifactId>
<version>5.5.2</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
<version>5.5.2</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.platform</groupId>
<artifactId>junit-platform-launcher</artifactId>
<version>1.5.2</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>5.5.2</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.platform</groupId>
<artifactId>junit-platform-engine</artifactId>
<version>1.5.2</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.platform</groupId>
<artifactId>junit-platform-runner</artifactId>
<version>1.5.2</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.1.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.2.1.RELEASE</version>
<scope>test</scope>
</dependency>

实体类bean
dog

package com.bean;

public class Dog {
private String name;

public Dog() {
//System.out.println("dog....." + name);
}

public void setName(String name) {
this.name = name;
}

public String getName() {
return name;
}
}

cat

package com.bean;

public class Cat {
private String name;
private int age;

public Cat() {
}

public void setName(String name) {
this.name = name;
}

public String getName() {
return name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

}

student

package com.bean;

import java.util.List;

public class Student {
private String name;
private String gender;
private int age;
private Dog dog;
private List<String> strs;

public Student() {

}

public Student(String name, List<String> strs, Dog dog) {
this.name = name;
this.strs = strs;
this.dog = dog;
}

public Student(Dog dog) {
this.dog = dog;
}

public Student(String name, String gender, int age) {
this.name = name;
this.gender = gender;
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getGender() {
return gender;
}

public void setGender(String gender) {
this.gender = gender;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public Dog getDog() {
return dog;
}

public List<String> getStrs() {
return strs;
}

@Override
public String toString() {
return "Student [name=" + name + ", gender=" + gender + ", age=" + age + ", dog=" + dog + "]";
}
}

spring注入配置类

<?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="cat" class="com.bean.Cat">
<property name="name">
<value>小花</value>
</property>
<property name="age" value="3" />
</bean>

<!-- 注入对象类型 -->
<bean id="dog" class="com.bean.Dog">
<property name="name" value="狗狗" />
</bean>
<bean id="person" class="com.bean.Person">
<property name="dog" ref="dog" />
<!-- <property name="birthday" ref="birthday" /> -->
<!-- 定义内部bean -->
<property name="birthday">
<!-- <ref bean="birthday"/> -->
<bean class="java.util.Date" />
</property>
</bean>
<!-- <bean id="birthday" class="java.util.Date" /> -->

<!-- 注入集合类型 -->
<bean id="col" class="com.bean.CustomCollection">
<property name="strs">
<array>
<value>java</value>
<value>mybaits</value>
<value>spring</value>
</array>
</property>
<property name="list">
<list>
<value>张飞</value>
<value>关羽</value>
<value>刘备</value>
</list>
</property>
<property name="set">
<set>
<value>hadoop</value>
<value>hive</value>
<value>hbase</value>
</set>
</property>
<property name="map">
<map>
<entry key="a" value="AA" />
<entry key="b" value="BB" />
<entry key="c" value="CC" />
</map>
</property>
<property name="props">
<props>
<prop key="driver">com.mysql.jdbc.Driver</prop>
<prop key="name">root</prop>
<prop key="password">123456</prop>
</props>
</property>
</bean>
</beans>

注入测试类

package com.test.setter;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;

import com.bean.Cat;
import com.bean.CustomCollection;
import com.bean.Person;

/**
* 注入
* 1、什么是注入?
* 注入也叫依赖注入,英文叫Dependency Injection。简单的说就给对象的属性赋值。
*
* 2、注入有以下几种方式:
* 1)属性注入
* 2)构造方法注入
*
* 3、注入有以下几种类型:
* 1)简单类型,使用value元素来指定
* 2)对象类型,使用ref元素来指定
* 3)集合类型,使用对应的集合元素
*
* 注意事项:
* 1)如果使用的是setter方法的属性注入,则对应属性的setXx()方法必须存在,否则会报
* org.springframework.beans.NotWritablePropertyException
* 2)对应属性注入,编写时都使用的字符串的方式,Spring可以根据最终的对象属性的类型
* 来做相应的转换。
* 3)如果注入的是对象,需要使用ref元素/属性来引用一个已经在配置文件中存在的bean的id值。
*
* 属性注入是通过使用<property></property>标签来完成的。
*/
@SpringJUnitConfig
public class App {
@Autowired
private Cat cat;
@Autowired
private Person person;
@Autowired
private CustomCollection col;

@Test
public void testSetter() {
System.out.println(cat.getName() + " " + cat.getAge());//小花 3
System.out.println(person.getDog().getName());//狗狗
System.out.println(person.getBirthday());//Wed Nov 06 17:07:03 GMT+08:00 2019
}

@Test
public void testCollection() {
String[] arr = col.getStrs();
System.out.println(Arrays.toString(arr));//[java, mybaits, spring]

List<String> list = col.getList();
System.out.println(list);//[张飞, 关羽, 刘备]

Set<String> set = col.getSet();
System.out.println(set);//[hadoop, hive, hbase]

Map<String, String> map = col.getMap();
System.out.println(map);//{a=AA, b=BB, c=CC}

Properties props = col.getProps();
System.out.println(props);//{password=123456, name=root, driver=com.mysql.jdbc.Driver}
}
}

配置文件
App-context.xml

<?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="student" class="com.bean.Student">
<constructor-arg name="gender" value="男" />
<constructor-arg name="age" value="20" />
<constructor-arg name="name" value="张三" />
</bean>

<!-- 注入对象类型 -->
<bean id="dog" class="com.bean.Dog">
<property name="name" value="旺财" />
</bean>
<bean id="student1" class="com.bean.Student">
<constructor-arg name="dog" ref="dog" />
</bean>

<!-- 注入集合类型 -->
<bean id="student2" class="com.bean.Student">
<constructor-arg name="name" value="黄飞鸿" />
<constructor-arg name="strs">
<list>
<value>A</value>
<value>B</value>
<value>C</value>
</list>
</constructor-arg>
<constructor-arg name="dog" ref="dog"/>
</bean>
</beans>

构造方法注入测试类:

package com.test.constructor;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;

import com.bean.Student;

/**
* 构造方法注入:
* 1、简单类型注入
* 2、对象类型注入
* 3、集合类型注入
*
* 构造方法注入是使用<constructor-arg></constructor-arg>标签来实现的。
*
* 注意:
* 1)使用<constructor-arg>可以指定一个构造器中的参数,如果有多个参数,则需要
* 多个<constructor-arg>标签来指定。(推荐使用)
* 2)<constructor-arg>标签的顺序就对应构造器中的参数列表顺序。
* 3)如果<constructor-arg>标签的顺序与构造器中参数列表的顺序不同,可以使用
* index属性来进行对应,index是从0开始。(不推荐使用)
* 4)还可以使用type属性来指定构造器参数列表中的参数的类型。(不推荐使用)
* 5)推荐使用name属性来指定。
*
* 如果想给某个属性设置null值,可以使用<null/>标签来完成。
*
* 总结:在开发中使用最多的是简单和对象的属性注入。
*/
@SpringJUnitConfig
public class App {
@Autowired
private Student student;

@Autowired
private Student student1;
@Autowired
private Student student2;

@Test
public void testConstructorInjection() {
System.out.println(student);//Student [name=张三, gender=男, age=20, dog=null]
System.out.println(student.getName().length());//2
}

@Test
public void testConstructorInjection1() {
System.out.println(student1);//Student [name=null, gender=null, age=0, dog=com.bean.Dog@2accdbb5]
System.out.println(student1.getDog().getName());//	旺财
}
@Test
public void testConstructorInjection2() {
System.out.println(student2);//Student [name=黄飞鸿, gender=null, age=0, dog=com.bean.Dog@2accdbb5]
System.out.println(student2.getStrs());//[A, B, C]
}
}

Spring配置文件

<?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="dog2" class="com.bean.Dog">
<property name="name" value="小白" />
</bean>
<bean id="dog1" class="com.bean.Dog">
<property name="name" value="小黑" />
</bean>
<!--
autowire标签是用于定义xml方式的自动装配策略,有以下几个值:
1)default:默认的方式,其值为no
2)no:表示不自动装配
3)byName:根据名称来自动装配,那在bean中定义的名称要与对象中的属性名称必须一至
4)byType:根据类型来自动装配,如果在配置文件中找到多个会报错误,如果一个都没有
找到也会报空指针错误。
5)constructor:根据构造器来自动装配(必须在类中提供一个构造器)
注意:在使用constructor进行自动装配时,构造器中的参数名称要与某个bean的名称
相同,否则报错。

推荐使用byName。
-->
<bean id="person" class="com.bean.Person" autowire="constructor"/>
</beans>

autowire标签测试类

package com.test.xml;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;

import com.bean.Dog;
import com.bean.Person;

@SpringJUnitConfig
public class App {
@Autowired
//private Person person;
private BeanFactory factory;

@Test
public void test01() {
Person person = factory.getBean("person", Person.class);
System.out.println("----" + person.getDog().getName());
}
@Test
public void test02() {
Dog dog = factory.getBean("dog2", Dog.class);
System.out.println(dog.getName());
}
}
  • 点赞
  • 收藏
  • 分享
  • 文章举报
一梦如意 发布了92 篇原创文章 · 获赞 1 · 访问量 1017 私信 关注
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: