目录
4.Test测试的java包里面创建一个包一个测试类去测试运行
4.Test测试的java包里面创建一个包一个测试类去测试运行
1.创建一个User类。里面带有名字和年龄属性,快捷键生成set方法和toString方法
2.创建一个spring的xml文件里面配置bean和注入属性具体的值
3. Test测试的java包里面创建一个包一个测试类去测试运行
1.创建一个User类。快捷键生成构造器方法和toString方法
2.创建一个spring的xml文件里面配置bean和注入属性具体的值
3. Test测试的java包里面创建一个包一个测试类去测试运行
一、介绍
1.set注入和构造器注入是什么?
2.通俗的理解
已知:当前的spring框架不需要自己创建对象了。这些对象都交给spring的bean容器去管理。
那么想要这些对象想要关联起来或者传值进去怎么办呢?
那就要用到注入。 例如一个Cat猫类对象想要使用Dog狗类中的方法。那么怎么办呢?
按照以前没有使用spring的思路就是:在Cat类中去实例化Dog类,然后调用Dog类的方法
用spring后:那就是在统一托管对象的spring容器里面去调用就好了。Cat类直接在spring容器里面调用Dog的方法就可以了
3.set注入和构造器注入的核心原理
(1)set注入的核心原理
通过反射机制调用set方法给属性赋值,让两个对象之间产生关系
(2)构造器注入的核心原理
通过调用构造方法来给属性赋值
4.set注入和构造器注入的类型
set注入有两种类型:引用类型、简单类型
构造器有两种类型:引用类型、简单类型
引用类型和简单类型区别:java数据类型(8个基本数据类型+3个引用数据类型)与数据类型转换知识点_java三种引用数据类型_云边的快乐猫的博客-CSDN博客
5.set注入的外部bean和内部bean
(1)外部bean:在spring的自定义xml配置bean文件中配置的bean含有ref引用的就是外部bean
(2)内部bean:在spring的自定义xml配置bean文件中配置的property标签再内嵌一个bean(不含id)
二、set注入和构造器注入例子步骤(引用数据类型)
(一)set注入
实验目标:创建一个Dog类,一个Cat类,交给spring中心托管。然后把Dog类的方法注入到Cat类里面,让Cat类去调用。本项目用的是maven项目
这里面有创建maven项目的方法
1.创建一个Dog类
package com.spring6.bean;
public class Dog {
//1.新建一个方法
public void DogEat(){
System.out.println("这是狗的方法");
}
}
2.创建一个Cat类
ps:被注入的Cat类里面要先写入要注入目标的私有对象.类.方法。然后生成一个set方法
然后类本身创建一个方法,去调用这个注入的对象方法
package com.spring6.bean;
public class Cat {
//一、要注入Cat里面的方法
//1.Dog私有方法
private Dog DogEat;
//2.生成一个set方法
public void setDog(Dog dog) {
this.DogEat = dog;
}
//二、写Cat自己的方法
public void cat(){
//3.调用注入狗的方法
DogEat.DogEat();
}
}
3.Dog类和Cat类统一交给spring管理
步骤:在resources里面创建一个配置xml文件。然后写入Dog和Cat这两个类的spring管理方式。
注入类:Dog。被注入类:Cat。就像Cat类里面被针管容器注入Dog类的方法
ps:不理解创建这个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">
<!--1.配置Dog的XML文件 id:自定义。class:类的全限名-->
<bean id="DogBean" class="com.spring6.bean.Dog"/>
<!--2..配置cat的XML文件 ps:被注入的类里面要添加注入的-->
<bean id="catBean" class="com.spring6.bean.Cat">
<!--name这里填的是:注入里面set方法去除set后,并首字母改为小写的单词。ref翻译为引用的意思 ref后面指定的是注入的id-->
<property name="dog" ref="DogBean"/>
</bean>
</beans>
4.Test测试的java包里面创建一个包一个测试类去测试运行
package com.spring6.text;
import com.spring6.bean.Cat;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class springTText {
@Test
public void TT(){
//1.半固定写法,扫描spring的xml文件(不固定的是要扫描的是哪个xml文件)
ApplicationContext applicationContext =new ClassPathXmlApplicationContext("spring.xml");
//2.半固定写法,获取spring里面要进行运行的类(不固定的是括号里面的,name为:要运行类的id,后面跟着的是要运行的类.class)
Cat catBean = applicationContext.getBean("catBean", Cat.class);
//3.上面自定义名.要运行类的方法
catBean.cat();
}
}
5.运行结果(Cat类被注入了Dog类的方法)
(二)构造器注入
实验目标:创建一个Dog类,一个Cat类,交给spring中心托管。然后把Dog类的方法注入到Cat类里面,让Cat类去调用。 目标和set一样,用的方式不一样而已
1.创建一个Dog类
package com.spring6.bean;
public class Dog {
//1.新建一个方法
public void DogEat(){
System.out.println("这是狗的方法");
}
}
2.创建一个Cat类
ps:被注入的Cat类里面要先写入要注入目标的私有对象.类.方法。然后生成一个构造方法
然后类本身创建一个方法,去调用这个注入的对象方法
3.Dog类和Cat类统一交给spring管理
步骤:在resources里面创建一个配置xml文件。然后写入Dog和Cat这两个类的spring管理方式。
注入类:Dog。被注入类:Cat。就像Cat类里面被针管容器注入Dog类的方法
ps:区别就是注入的这里这个可以自动扫描,也可以用name,也可以用序列号
<?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">
<!--1.配置Dog的XML文件 id:自定义。class:类的全限名-->
<bean id="DogBean" class="com.spring6.bean.Dog"/>
<!--2..配置cat的XML文件 ps:被注入Cat类里面要添加注入的Dog-->
<bean id="catBean" class="com.spring6.bean.Cat">
<!--constructor-arg这个会自动扫描。ref翻译为引用的意思 ref后面指定的是注入Dog的id-->
<constructor-arg ref="DogBean"/>
</bean>
</beans>
4.Test测试的java包里面创建一个包一个测试类去测试运行
ps:这个和set注入的第4步一样
package com.spring6.text;
import com.spring6.bean.Cat;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class springTText {
@Test
public void TT(){
//1.半固定写法,扫描spring的xml文件(不固定的是要扫描的是哪个xml文件)
ApplicationContext applicationContext =new ClassPathXmlApplicationContext("spring.xml");
//2.半固定写法,获取spring里面要进行运行的类(不固定的是括号里面的,name为:要运行类的id,后面跟着的是要运行的类.class)
Cat catBean = applicationContext.getBean("catBean", Cat.class);
//3.上面自定义名.要运行类的方法
catBean.cat();
}
}
5.运行结果(Cat类被注入了Dog类的方法)
ps:这个和set注入的第5步一样
二、set注入和构造器注入例子步骤 (简单数据类型)
实验目标:创建一个User类,属性有名字和年龄。用spring的xml方式注入具体的值
(一)set注入
1.创建一个User类。里面带有名字和年龄属性,快捷键生成set方法和toString方法
package com.spring6.bean;
public class User {
//1.创建类的属性
private String username;
private int age;
//2.快捷键生成set方法
public void setUsername(String username) {
this.username = username;
}
public void setAge(int age) {
this.age = age;
}
//3.快捷键生成toString方法
@Override
public String toString() {
return "User{" +
"username='" + username + '\'' +
", age=" + age +
'}';
}
}
2.创建一个spring的xml文件里面配置bean和注入属性具体的值
<?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">
<!--1.配置User的XML文件 id:自定义 class:要设置类的全限名-->
<bean id="userBean" class="com.spring6.bean.User">
<!--2.用property name:要注入的属性名称 简单类型用value:注入属性的值 -->
<property name="username" value="张三"/>
<property name="age" value="18"/>
</bean>
</beans>
3. Test测试的java包里面创建一个包一个测试类去测试运行
package com.spring6.text;
import com.spring6.bean.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class springTText {
@Test
public void TT(){
//1.半固定写法,扫描spring的xml文件(不固定的是要扫描的是哪个xml文件)
ApplicationContext applicationContext =new ClassPathXmlApplicationContext("spring.xml");
//2.半固定写法,获取spring里面要进行运行的类(不固定的是括号里面的,name为:要运行类的id,后面跟着的是要运行的类.class)
User username = applicationContext.getBean("userBean", User.class);
//3.运行这个方法
System.out.println(username);
}
}
4.运行结果
(二)构造器注入
1.创建一个User类。快捷键生成构造器方法和toString方法
package com.spring6.bean;
public class User {
//1.创建类的属性
private String username;
private int age;
public User(String username, int age) {
this.username = username;
this.age = age;
}
@Override
public String toString() {
return "User{" +
"username='" + username + '\'' +
", age=" + age +
'}';
}
}
2.创建一个spring的xml文件里面配置bean和注入属性具体的值
<?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">
<!--1.配置User的XML文件 id:自定义 class:要设置类的全限名-->
<bean id="userBean" class="com.spring6.bean.User">
<!--2.constructor-arg:自动扫描属性 value:里面填入要注入属性的具体值 -->
<constructor-arg value="李四"/>
<constructor-arg value="19"/>
</bean>
</beans>
3. Test测试的java包里面创建一个包一个测试类去测试运行
package com.spring6.text;
import com.spring6.bean.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class springTText {
@Test
public void TT(){
//1.半固定写法,扫描spring的xml文件(不固定的是要扫描的是哪个xml文件)
ApplicationContext applicationContext =new ClassPathXmlApplicationContext("spring.xml");
//2.半固定写法,获取spring里面要进行运行的类(不固定的是括号里面的,name为:要运行类的id,后面跟着的是要运行的类.class)
User username = applicationContext.getBean("userBean", User.class);
//3.运行这个方法
System.out.println(username);
}
}
4.运行结果
ps:感觉set注入和构造注入就快捷键生成的代码不一样,一个生成set方法,一个生成构造器方法。xml配置里面也有些细微不一样而已,其他的大致一样