<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<spring.version>4.3.18.RELEASE</spring.version>
<lombok.version>1.16.18</lombok.version>
<junit.version>4.11</junit.version>
</properties>
<dependencies>
<!-- spring-beans begin -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- spring-beans end -->
<!-- spring-core begin -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- spring-core end -->
<!-- spring-context begin -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- spring-context end -->
<!-- spring-expression begin -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-expression</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- spring-expression end -->
</dependencies>
<?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">
<!-- 基于spring的核心配置文件方式,手动配置一个bean,放到spring的容器中 -->
<bean id="userOne" class="com.kgc.spring.bean.User">
<property name="nickName" value="kh96_spring_one"></property>
</bean>
</beans>
<bean>标签:定义一个实例对象,会自动被创建 并 交给spring容器进行管理:
id 属性:被spring容器进行管理的实例的 唯一标识,整个容器中,只能是唯一的(不可重复);
class属性:指定创建当前实例对象的类型(全类名),spring底层是使用的 反射机制 ,根据指定的目标类型,创建目标实例(必须有 空参构造)
<property>子标签:给当前创建对象的属性值
@Test
public void testSpringPrimer(){
//1.创建spring的核心容器对象(引用上下文对象),解析spring的核心配置文件,将文件中的bean标签进行实例化(创建对象并赋值)
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//2. 写法一: 从容器中获取实例对象,根据核心配置文件中,配置的bean标签的id属性值
// 不足:强制转化,容易出现转换错误
User userOne = (User) context.getBean("userOne");
userOne.sayHello();
//对比以前创建对象的写法(对象必须手动new创建,并手动赋值)
User userOld = new User();
userOld.setNickName("kh96_old");
userOld.sayHello();
}
通过id属性,获取实例对象后需要强制转换,容易出现强制转化错误;
//写法二:从容器中获取实例对象,根据核心配置文件中,配置的bean标签的class属性指定的目标类型
User userTwo = context.getBean(User.class);
userTwo.sayHello();
不足:如果存在同类型的多个实例,会报异常;
当用多个同类型的实例:
...
<bean id="userOne" class="com.kgc.spring.bean.User">
<property name="nickName" value="kh96_spring_one"></property>
</bean>
<!-- Configuration problem: Bean name 'userOne' is already used in this <beans> element -->
<bean id="userTwo" class="com.kgc.spring.bean.User">
<property name="nickName" value="kh96_spring_two"></property>
</bean>
...
User userTwo = context.getBean(User.class);
会发生异常:
NoUniqueBeanDefinitionException: No qualifying bean of type 'com.kgc.spring.bean.User' available: expected single matching bean but found 2: userOne,userTwo
主要原因是由于只用class属性去获取实例,但是有多个相同类型的实例,所以无法确定你要获取的是哪一个;
//写法三:从容器中获取实例对象,根据配置文件中,配置的bean标签的id属性值和class属性指定的目标类型
User userTwoThree = context.getBean("userTwo", User.class);
能够确定唯一实例,推荐使用;
配置文件中的id必须是唯一的;
如果id不唯一:两个id一样的实例
...
<bean id="userOne" class="com.kgc.spring.bean.User">
<property name="nickName" value="kh96_spring_one"></property>
</bean>
<bean id="userOne" class="com.kgc.spring.bean.User">
<property name="nickName" value="kh96_spring_one"></property>
</bean>
...
报错:
BeanDefinitionParsingException: Configuration problem: Bean name 'userOne' is already used in this <beans> element
提示 id 为 userOne 的实例已经存在;
当初始化spring的容器对象时,会将核心配置文件中所有的bean实例化,不是使用哪个,创建哪个;
IOC(控制反转是一种思想),DI是IOC的一种实现方式;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
//用户昵称
//普通参数
private String nickName;
//私家车
//实体参数
private Car car;
//喜欢的书
//数组参数
private String[] books;
//爱好
//list集合参数
private List<String> hobbies;
//喜欢的游戏
//set 集合
private Set<String> games;
//卡包
//map参数
private Map<String,String> cards;
//在校信息
//properties参数
private Properties info;
//是否有女朋友 (主要是演示赋值为null,其他类型都可以)
//空参数注入
private Boolean wife;
}
...
<!-- 不同类型参数的set注入 -->
<bean id="user01" class="com.kgc.spring.bean.User">
<!-- 1.普通参数 注入 -->
<property name="nickName" value="小气鬼"></property>
<!-- 2.实体参数 注入 -->
<!-- 2.1 实体参数 注入方式一 外部引入 ref -->
<!-- <property name="car" ref="carOne"></property>-->
<property name="car">
<!-- 2.2 实体参数注入方式二 内部注入 <bean> -->
<bean class="com.kgc.spring.bean.Car">
<property name="brand" value="Bmw325"></property>
<property name="factory" value="华晨"></property>
<property name="price" value="300000"></property>
</bean>
</property>
<!-- 3.数组参数 注入 -->
<property name="books">
<array>
<value>红楼梦</value>
<value>水浒传</value>
<value>三国演义</value>
<value>西游记</value>
</array>
</property>
<!-- 4.list集合参数 -->
<property name="hobbies" >
<list>
<value>跑步</value>
<value>尤克里里</value>
<value>敲代码</value>
</list>
</property>
<!-- 5.set 集合参数 注入 -->
<property name="games">
<set>
<value>唱歌</value>
<value>跳舞</value>
<value>喝酒</value>
</set>
</property>
<!-- 6.map参数 -->
<property name="cards">
<map>
<entry key="身份证" value="1212121212121212"></entry>
<entry key="银行卡" value="1111111111111111"></entry>
</map>
</property>
<!-- 7.properties参数 -->
<property name="info">
<props>
<prop key="学号">123456</prop>
<prop key="性别">男</prop>
<prop key="姓名">化羽</prop>
</props>
</property>
<!-- 8.空参数注入 -->
<property name="wife">
<null></null>
</property>
</bean>
<bean id="carOne" class="com.kgc.spring.bean.Car">
<property name="brand" value="Bmw325"></property>
<property name="factory" value="华晨"></property>
<property name="price" value="300000"></property>
</bean>
...
@Test
public void testPramsDI(){
User user01 = context.getBean("user01", User.class);
//输入对象详情
System.out.println(user01);
}
输出结果:
User(
nickName=小气鬼,
car=Car(brand=Bmw325, factory=华晨, price=300000.0),
books=[红楼梦, 水浒传, 三国演义, 西游记],
hobbies=[跑步, 尤克里里, 敲代码],
games=[唱歌, 跳舞, 喝酒],
cards={身份证=1212121212121212, 银行卡=1111111111111111},
info={学号=1913001072, 性别=男, 姓名=化羽},
wife=null
)
<!--
实体构造方法:Car(String brand, String factory, Double price)
-->
<!-- 构造器注入:通过构造方法,默认是按照构造方法的参数定义顺序赋值 -->
<bean id="carTwo" class="com.kgc.spring.bean.Car">
<constructor-arg value="AudiA4"></constructor-arg>
<constructor-arg value="一汽"></constructor-arg>
<constructor-arg value="320000"></constructor-arg>
</bean>
@Test
public void testSpringDIConstructor(){
Car carTwo = context.getBean("carTwo", Car.class);
//输出对象详情
System.out.println(carTwo);
}
<!-- 根据构造器中参数的下标 和 类型 赋值 -->
<bean id="carThree" class="com.kgc.spring.bean.Car">
<constructor-arg index="0" value="BenzC200"></constructor-arg>
<constructor-arg index="1" value="北京"></constructor-arg>
<constructor-arg index="2" type="java.lang.Double" value="350000"></constructor-arg>
<!--
如果参数列表中,该类型的参数只用一个,也可以只指定参数类型
<constructor-arg type="java.lang.Double" value="350000"></constructor-arg>
-->
</bean>
@Test
public void testSpringDIConstructor2(){
Car carTwo = context.getBean("carThree", Car.class);
//输入对象详情
System.out.println(carTwo);
}
自定义实体工厂bean ,必须实现FactoryBean接口;
普通bean 与 工厂bean 的区别:
@Data
@ToString
public class Car {
/*
品牌
*/
private String brand;
/*
厂商
*/
private String factory;
/*
价格
*/
private Double price;
}
public class CarFactoryBean implements FactoryBean<Car> {
@Override
public Car getObject() throws Exception {
System.out.println("通过CarFactoryBean的实例对象的getObject方法:返回一个自定义的car的实例");
return new Car("Byd唐","南京",2500000.0);
}
@Override
public Class<?> getObjectType() {
//指定给Object方法返回的目标类型
return Class.class;
}
@Override
public boolean isSingleton() {
//是否单例
return false;
}
}
...
<!-- 使用工厂bean容器,添加自定义实例对象 -->
<bean id="carFactoryBean" class="com.kgc.spring.bean.CarFactoryBean"></bean>
...
@Test
public void testSpringFactoryBean(){
//从容器中获取工厂bean的实例对象
Car car1 = context.getBean("carFactoryBean", Car.class);
Car car2 = context.getBean("carFactoryBean", Car.class);
//输出对象详情
System.out.println(car 1);
//在容器中添加的实例是 CarFactoryBean 类型,返回的是
//Car(brand=Byd唐, factory=南京, price=2500000.0)
System.out.println("car1 == car2 : " + ( car1 == car2));
//false 说明工厂bean是多例的
}
这里区别于,整个程序运行期间,有且只有唯一的实例(单例模式-懒汉和饿汉);
而容器中bean的单例,不是指当前类的实例在容器中,只有唯一的实例,而是当创建bean的实例时,此实例是单例(容器内唯一),但是同一个类的实例,容器中可以创建多个,每个都是单例的;
<!-- scope="singleton" 不写默认也是单例的 -->
<bean id="busTwo" class="com.kgc.spring.bean.Bus" scope="singleton">
<property name="brand" value="金龙2"></property>
<property name="factory" value="厦门2"></property>
<property name="price" value="1200000"></property>
</bean>
@Test
public void testScopeSingleton(){
//从容器中,获取Bus的实例对象
Bus busThree = context.getBean("busTwo", Bus.class);
Bus busFour = context.getBean("busTwo", Bus.class);
System.out.println(busThree);
System.out.println(busFour);
System.out.println("singleton busThree == busFour:"+(busThree == busFour));
//true
}
多例:prototype,不是spring容器中的默认作用,需要单独指定;
spring容器创建时,不会自动创建指定作用域为多例的bean的实例,而是每次通过getBean方法,获取bean的实例,才会创建bean的实例;
<!-- scope="prototype" 多例需要手动设置 -->
<bean id="busThree" class="com.kgc.spring.bean.Bus" scope="prototype">
<property name="brand" value="中通3"></property>
<property name="factory" value="山东3"></property>
<property name="price" value="1200000"></property>
</bean>
@Test
public void testScopePrototype(){
Bus busOne = context.getBean("busThree", Bus.class);
Bus busTwo = context.getBean("busThree", Bus.class);
//输入详情
System.out.println(busOne);
System.out.println(busTwo);
System.out.println("prototype busOne == busTwo:"+(busOne == busTwo));
//false
}
转载自: https://www.cnblogs.com/xiaoqigui/p/16625420.html