1. IOC底层原理
1.1 什么是IOC
(1)控制反转缩写为IOC,把对象创建和对象之间的调用过程,交给Spring管理
(2)使用IOC目的:为了降低耦合度
1.2 底层原理
(1)xml解析
(2)工厂模式
(3)反射
2. IOC接口(BeanFactory)
IOC思想基于IOC容器完成,IOC容器底层就是对象工厂
Spring中提供IOC容器实现的两种方式:
-
BeanFactory
IOC容器基本实现,是Spring内部的使用接口,开发中一般不去使用
特点:加载配置文件时不创建对象,在获取对象(使用)时才去创建对象
-
ApplicationContext
BeanFactory接口的子接口,比BeanFactory提供了更多更强大的功能,一般由开发人员进行使用
特点:加载配置文件的时候就会把在配置文件中的对象进行创建
-
ApplicationContext接口有实现类
3. IOC操作Bean管理
Bean管理指的是两个操作:
- Spring创建对象
- Spring注入属性
3.1 基于xml管理Bean
以下所有示例代码中xml及properties配置文件都放置于src目录下
3.1.1 基于xml创建对象
- 在spring配置文件中,使用bean标签,标签里面添加对应属性,就可以实现对象创建
- bean标签的属性:
- id:唯一标识
- class:类全路径
- name:可以加入特殊符号的name(不推荐使用,用id替代)
- 创建对象的时候,默认使用无参构造方法完成对象创建
java类
public class User {
public void add() {
System.out.println("调用了add方法");
}
}
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">
<!-- 配置User类对象的创建 -->
<bean id="user" class="com.study.spring5.User"></bean>
</beans>
主方法
public class Main {
public static void main(String[] args) {
// 1. 加载spring配置文件
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("bean1.xml");
// 2. 获取配置创建的对象
User user = applicationContext.getBean("user", User.class);
// 3. 调用对象方法
user.add();
}
}
3.1.2 基于xml方式注入属性
-
DI:依赖注入,就是注入属性
DI是IOC的一种实现
-
注入方式:
- 使用set方法进行注入
- 使用有参构造进行注入
-
使用spring的xml方式注入
3.1.2.1 通过set方法注入
java类
public class User {
private String name;
public void add() {
System.out.println("调用了add方法");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
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">
<!-- 配置User类对象的创建 -->
<bean id="user" class="com.study.spring5.User">
<property name="name" value="小明"/>
</bean>
</beans>
主方法
public class Main {
public static void main(String[] args) {
// 1. 加载spring配置文件
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("bean1.xml");
// 2. 获取配置创建的对象
User user = applicationContext.getBean("user", User.class);
// 3. 调用对象方法
user.add();
// 4. 查看注入的属性内容
System.out.println(user.getName());
}
}
3.1.2.2 通过构造方法注入
java类
public class Department {
private String deptName;
public Department() {
}
public Department(String deptName) {
this.deptName = deptName;
}
@Override
public String toString() {
return "Dept{" +
"deptName='" + deptName + '\'' +
'}';
}
}
xml配置文件
<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">
<!-- 配置Department类对象的创建 -->
<bean id="department" class="com.study.spring5.Department">
<constructor-arg name="deptName" value="研发部"/>
</bean>
</beans>
主方法
public class Main {
public static void main(String[] args) {
// 1. 加载spring配置文件
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("bean1.xml");
// 2. 获取配置创建的对象
Department department = applicationContext.getBean("department", Department.class);
// 3. 查看注入的属性内容
System.out.println(department);
}
}
3.1.2.3 通过p名称空间注入
xml配置文件中添加p名称空间
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
bean标签为
<bean id="user" class="com.study.spring5.User" p:name="小明"/>
3.1.2.4 注入空值和特殊符号
java类
public class User {
private String name;
private String add;
public void add() {
System.out.println("调用了add方法");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAdd() {
return add;
}
public void setAdd(String add) {
this.add = add;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", add='" + add + '\'' +
'}';
}
}
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">
<!-- 配置User类对象的创建 -->
<bean id="user" class="com.study.spring5.User">
<property name="name" value="小明"/>
<!-- 向这个属性中设置一个空值 -->
<property name="address">
<null/>
</property>
</bean>
</beans>
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"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 配置User类对象的创建 -->
<bean id="user" class="com.study.spring5.User">
<property name="name" value="小明"/>
<!-- 属性中包含<>特殊符号
方法1:使用<>进行转义
方法2:把带特殊符号的内容写到CDATA中
-->
<property name="address">
<value><![CDATA[<山东>]]></value>
</property>
</bean>
</beans>
3.1.2.5 注入外部Bean
创建service和dao包,分别创建UserDao、UserDaoImpl和UserService,service需要调用dao
UserDao
public interface UserDao {
void add();
}
UserDaoImpl
public class UserDaoImpl implements UserDao {
@Override
public void add() {
System.out.println("dao层add()方法");
}
}
UserService
public class UserService {
private UserDao userDao;
public void add() {
System.out.println("service层add()方法");
userDao.add();
}
public UserDao getUserDao() {
return userDao;
}
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
}
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. 创建dao对象 -->
<bean id="userDao" class="com.study.spring5.demo02.dao.UserDaoImpl"/>
<!-- 2. 创建service,并且注入dao对象 -->
<bean id="userService" class="com.study.spring5.demo02.service.UserService">
<property name="userDao" ref="userDao"/>
</bean>
</beans>
主方法
public class Main {
public static void main(String[] args) {
// 1. 加载spring配置文件
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean2.xml");
// 2. 获取配置创建的对象
UserService userService = applicationContext.getBean("userService", UserService.class);
// 3. 调用对象方法
userService.add();
}
}
3.1.2.6 注入内部bean和级联赋值
(1)一对多关系:部门跟员工
一个部门拥有多个员工
部门类Dept
public class Dept {
private String dName;
public String getdName() {
return dName;
}
public void setdName(String dName) {
this.dName = dName;
}
@Override
public String toString() {
return "Dept{" +
"dName='" + dName + '\'' +
'}';
}
}
Emp员工类
public class Emp {
private String eName;
private String gender;
// 员工属于一个部门
private Dept dept;
public String geteName() {
return eName;
}
public void seteName(String eName) {
this.eName = eName;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public Dept getDept() {
return dept;
}
public void setDept(Dept dept) {
this.dept = dept;
}
@Override
public String toString() {
return "Emp{" +
"eName='" + eName + '\'' +
", gender='" + gender + '\'' +
", dept=" + dept +
'}';
}
}
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. 创建Emp对象 -->
<bean id="emp" class="com.study.spring5.demo03.bean.Emp">
<property name="eName" value="杰克王"/>
<property name="gender" value="男"/>
<property name="dept">
<bean id="dept" class="com.study.spring5.demo03.bean.Dept">
<property name="dName" value="市场部"/>
</bean>
</property>
<!-- 也可以使用以下形式 -->
<!-- <property name="dept.dName" value="市场部"/>-->
</bean>
</beans>
主方法
public class Main {
public static void main(String[] args) {
// 1. 加载spring配置文件
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("bean3.xml");
// 2. 获取配置创建的对象
Emp emp = applicationContext.getBean("emp", Emp.class);
System.out.println(emp);
}
}
3.1.2.7 注入集合类型
Student学生类
public class Student {
private String[] courses;
private List<String> list;
private Map<String, String> map;
public String[] getCourses() {
return courses;
}
public void setCourses(String[] courses) {
this.courses = courses;
}
public List<String> getList() {
return list;
}
public void setList(List<String> list) {
this.list = list;
}
public Map<String, String> getMap() {
return map;
}
public void setMap(Map<String, String> map) {
this.map = map;
}
@Override
public String toString() {
return "Student{" +
"courses=" + Arrays.toString(courses) +
", list=" + list +
", map=" + map +
'}';
}
}
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. 创建Student对象 -->
<bean id="student" class="com.study.spring5.demo04.Student">
<property name="courses">
<!-- list或者array标签均可 -->
<list>
<value>语文</value>
<value>数学</value>
<value>英语</value>
</list>
</property>
<!-- <property name="list" value="list1, list2, list3"></property>-->
<!-- <property name="list">-->
<!-- <value>list1, list2, list3</value>-->
<!-- </property>-->
<property name="list">
<list>
<value>list1</value>
<value>list2</value>
<value>list3</value>
</list>
</property>
<property name="map">
<map>
<entry key="key1" value="value1"/>
<entry key="key2" value="value2"/>
<entry key="key3" value="value3"/>
</map>
</property>
</bean>
</beans>
主方法
public class Main {
public static void main(String[] args) {
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("bean4.xml");
Student student = applicationContext.getBean("student", Student.class);
System.out.println(student);
}
}
3.1.2.8 在集合里面设置对象类型值
Course课程类
public class Course {
private String courseName;
public Course() {
}
public Course(String courseName) {
this.courseName = courseName;
}
public String getCourseName() {
return courseName;
}
public void setCourseName(String courseName) {
this.courseName = courseName;
}
@Override
public String toString() {
return "Course{" +
"courseName='" + courseName + '\'' +
'}';
}
}
Student学生类
public class Student {
private List<Course> courseList;
public List<Course> getCourseList() {
return courseList;
}
public void setCourseList(List<Course> courseList) {
this.courseList = courseList;
}
@Override
public String toString() {
return "Student{" +
"courseList=" + courseList +
'}';
}
}
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. 创建Student对象 -->
<bean id="student" class="com.study.spring5.demo04.Student">
<!-- 注入list集合类型,值是对象 -->
<property name="courseList">
<list>
<!-- 注入第一个course对象 -->
<ref bean="course1"/>
<!-- 注入第二个course对象 -->
<ref bean="course2"/>
</list>
</property>
</bean>
<!-- 2. 创建多个Course对象 -->
<bean id="course1" class="com.study.spring5.demo04.Course">
<property name="courseName" value="java"/>
</bean>
<bean id="course2" class="com.study.spring5.demo04.Course">
<property name="courseName" value="spring"/>
</bean>
</beans>
主方法
public class Main {
public static void main(String[] args) {
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("bean4.xml");
Student student = applicationContext.getBean("student", Student.class);
System.out.println(student);
}
}
3.1.2.9 提取集合注入部分
(1)在spring配置文件中引入名称空间 util
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
</beans>
(2)使用util标签完成list集合注入提取并使用
Book图书类
public class Book {
private List<String> list;
public List<String> getList() {
return list;
}
public void setList(List<String> list) {
this.list = list;
}
@Override
public String toString() {
return "Book{" +
"list=" + list +
'}';
}
}
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"
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
<!-- 1. 提取list集合类型属性注入 -->
<util:list id="bookList">
<value>java入门</value>
<value>spring入门</value>
<value>springmvc入门</value>
</util:list>
<!-- 2. 提取list集合类型属性注入使用 -->
<bean id="book" class="com.study.spring5.demo05.Book">
<property name="list" ref="bookList"/>
</bean>
</beans>
主方法
public class Main {
public static void main(String[] args) {
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("bean5.xml");
Book book = applicationContext.getBean("book", Book.class);
System.out.println(book);
}
}
3.2 FactoryBean
Spring有两种类型,一种普通bean,另外一种称为工厂bean(FactoryBean)
-
普通bean
在spring配置文件中,定义的bean类型就是返回类型
-
工厂bean
在配置文件定义bean类型可以和返回类型不一样
第一步:创建一个类,让这个类作为工厂bean,实现接口FactoryBean
第二步:实现接口里面的方法,在实现的方法中定义返回的bean类型
MyBean类
public class MyBean { private String str; public MyBean() { } public MyBean(String str) { this.str = str; } public String getStr() { return str; } public void setStr(String str) { this.str = str; } @Override public String toString() { return "MyBean{" + "str='" + str + '\'' + '}'; } }
MyFactoryBean
public class MyFactoryBean implements FactoryBean<MyBean> { // 定义返回的bean @Override public MyBean getObject() throws Exception { MyBean myBean = new MyBean(); myBean.setStr("MyFactoryBean::getObject方法中返回的对象"); return myBean; } @Override public Class<?> getObjectType() { return null; } }
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="myBean" class="com.study.spring5.demo06.MyBean"> <property name="str" value="字符串"/> </bean> <bean id="myFactoryBean" class="com.study.spring5.demo06.MyFactoryBean"/> </beans>
主方法
public class Main { public static void main(String[] args) { ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean6.xml"); MyBean myBean = applicationContext.getBean("myBean", MyBean.class); System.out.println(myBean); // 会报错 //Bean named 'myFactoryBean' is expected to be of type 'com.study.spring5.demo06.MyFactoryBean' // but was actually of type 'com.study.spring5.demo06.MyBean' // MyFactoryBean myFactoryBean = applicationContext.getBean("myFactoryBean", MyFactoryBean.class); // System.out.println(myFactoryBean); MyBean myBean1 = applicationContext.getBean("myFactoryBean", MyBean.class); System.out.println(myBean1); } }
3.3 bean的作用域
在Spring里面,可以设置创建的bean实例是单实例还是多实例的。默认情况下bean为单实例对象。
设置单实例和多实例方法:
-
通过xml配置文件bean标签中的scope属性,scope属性有两个常用值
(1)singleton:表示创建对象时为单实例对象
(2)prototype:表示创建对象时为多实例对象
(3)singleton和prototype的区别
singleton表示单实例,prototype表示多实例
设置scope值为singleton时,加载spring配置文件的时候就会创建一个单实例对象
设置scope值为prototype时,不是在加载spring配置文件时创建对象,而是在调用getBean方法时创建多实例对象
-
实现FactoryBean接口重写isSingleton()方法
注意:实现接口重写方法的优先级大于通过xml配置文件bean标签中的scope属性
MyFactory类
public class MyFactoryBean implements FactoryBean<MyBean> {
// 定义返回的bean
@Override
public MyBean getObject() throws Exception {
MyBean myBean = new MyBean();
myBean.setStr("MyFactoryBean::getObject方法中返回的对象");
return myBean;
}
@Override
public Class<?> getObjectType() {
return null;
}
@Override
public boolean isSingleton() {
// 这里返回true时,创建的对象为单实例,返回false时,为多实例
return false;
}
}
MyBean类
public class MyBean {
private String str;
public MyBean() {
}
public MyBean(String str) {
this.str = str;
}
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
}
@Override
public String toString() {
return "MyBean{" +
"str='" + str + '\'' +
'}';
}
}
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="myBean" class="com.study.spring5.demo06.MyBean">
<property name="str" value="字符串"/>
</bean>
<bean id="myFactoryBean" class="com.study.spring5.demo06.MyFactoryBean"/>
<!-- 也可以通过 bean标签中的scope属性进行设置 不过优先级低于实现接口重写isSingleton()方法 -->
<!-- <bean id="myFactoryBean" class="com.study.spring5.demo06.MyFactoryBean" scope="singleton"/>-->
<!-- <bean id="myFactoryBean" class="com.study.spring5.demo06.MyFactoryBean" scope="prototype"/>-->
</beans>
主方法
public class Main {
public static void main(String[] args) {
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("bean6.xml");
MyBean myBean1 = applicationContext.getBean("myFactoryBean", MyBean.class);
System.out.println(myBean1);
MyBean myBean2 = applicationContext.getBean("myFactoryBean", MyBean.class);
if (myBean1 == myBean2) {
System.out.println("单实例模式创建");
} else {
System.out.println("多实例模式创建");
}
}
}
3.4 bean的生命周期
-
生命周期:
(1)从对象创建到对象销毁的过程
-
bean的生命周期
(1)通过构造器创建bean实例(无参数构造)
(2)为bean的属性设置值和对其他bean的引用(调用set方法)
(3)调用bean的初始化方法(需要配置初始化的方法)
(4)bean可以使用(获取到对象)
(5)当容器关闭时候,调用bean的销毁的方法(需要配置销毁的方法)
-
演示bean的生命周期
Order类
public class Order { private String orderName; public Order() { System.out.println("第一步 执行无参构造方法创建bean实例"); } public String getOrderName() { return orderName; } public void setOrderName(String orderName) { this.orderName = orderName; System.out.println("第二步 调用set方法设置属性值"); } // 创建执行的初始化方法 public void initMethod() { System.out.println("第三步 执行初始化方法"); } // 创建执行的销毁方法 public void destoryMethod() { System.out.println("第五步 执行销毁方法"); } }
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"> <!-- init-method属性用来指定初始化方法 destroy-method属性用来指定销毁方法--> <bean id="order" class="com.study.spring5.demo07.Order" init-method="initMethod" destroy-method="destoryMethod"> <property name="orderName" value="小米10"/> </bean> </beans>
主方法
public class Main { public static void main(String[] args) { ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean7.xml"); Order order = applicationContext.getBean("order", Order.class); System.out.println("第四步 获取到创建的对象" + order); // 手动让bean实例销毁 ((ClassPathXmlApplicationContext) applicationContext).close(); } }
-
bean的后置处理器
bean的生命周期中,步骤三中还可以进行拆分
(1)通过构造器创建bean实例(无参数构造)
(2)为bean的属性设置值和对其他bean的引用(调用set方法)
(3-1)把bean实例传递给bean后置处理器
(3-2)调用bean的初始化方法(需要配置初始化的方法)
(3-3)把bean实例传递给bean后置处理器
(4)bean可以使用(获取到对象)
(5)当容器关闭时候,调用bean的销毁的方法(需要配置销毁的方法)
添加后置处理器
(1)创建一个类,实现BeanPostProcessor接口,创建后置处理器
public class MyBeanPostProcessor implements BeanPostProcessor { // 初始化前执行的方法 @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { System.out.println("初始化前执行的方法"); return bean; } // 初始化后执行的方法 @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { System.out.println("初始化后执行的方法"); return bean; } }
(2)修改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"> <!-- init-method属性用来指定初始化方法 destroy-method属性用来指定销毁方法--> <bean id="order" class="com.study.spring5.demo07.Order" init-method="initMethod" destroy-method="destoryMethod"> <property name="orderName" value="小米10"/> </bean> <!-- 配置后置处理器 --> <bean id="myBeanPostProcessor" class="com.study.spring5.demo07.MyBeanPostProcessor"/> </beans>
3.5 xml自动装配
-
什么是自动装配
根据指定的装配规则(属性名称或者属性类型),Spring自动将匹配的属性值进行注入
-
演示自动装配
(1)根据属性名称进行自动装配
Emp类
public class Emp { private Dept dept; public Dept getDept() { return dept; } public void setDept(Dept dept) { this.dept = dept; } @Override public String toString() { return "Emp{" + "dept=" + dept + '}'; } }
Dept类
public class Dept { @Override public String toString() { return "Dept{}"; } }
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="dept" class="com.study.spring5.demo08.Dept"/> <!-- 实现自动装配 bean标签autowire,配置自动装配 autowire属性常用两个值: byName:根据属性名称进行注入,注入值bean的id的值和类属性的名称要一致 byType:根据属性类型进行注入 --> <bean id="emp" class="com.study.spring5.demo08.Emp" autowire="byName"/> </beans>
主方法
public class Main { public static void main(String[] args) { ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean8.xml"); Emp emp = applicationContext.getBean("emp", Emp.class); System.out.println(emp); } }
3.6 外部属性文件
-
直接配置数据库信息
(1)配置连接池
(2)引入druid连接池jar包和mysql连接jar包
(3)编写配置文件进行测试
<?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"> <!-- 直接配置druid连接池 --> <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/sys"/> <property name="username" value="root"/> <property name="password" value="admin"/> </bean> </beans>
主方法
public class Main { public static void main(String[] args) throws SQLException { ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean9.xml"); DruidDataSource dataSource = applicationContext.getBean("dataSource", DruidDataSource.class); DruidPooledConnection connection = dataSource.getConnection(); System.out.println(connection + "连接创建成功"); } }
-
引入外部属性文件配置数据库连接池
(1)创建jdbc.properties外部属性文件,写入数据库信息
mysql.driverClassName=com.mysql.jdbc.Driver mysql.url=jdbc:mysql://localhost:3306/sys mysql.username=root mysql.password=admin
(2)把外部properties属性文件引入到spring配置文件中
引入context名称空间
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"> </beans>
(3)在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" xmlns:util="http://www.springframework.org/schema/util" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"> <!-- 引入外部属性标签 --> <context:property-placeholder location="jdbc.properties"/> <!-- 直接配置druid连接池 --> <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> <property name="driverClassName" value="${mysql.driverClassName}"/> <property name="url" value="${mysql.url}"/> <property name="username" value="${mysql.username}"/> <property name="password" value="${mysql.password}"/> </bean> </beans>
(4)进行测试
public class Main { public static void main(String[] args) throws SQLException { ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean9.xml"); DruidDataSource dataSource = applicationContext.getBean("dataSource", DruidDataSource.class); DruidPooledConnection connection = dataSource.getConnection(); System.out.println(connection + "连接创建成功"); connection.close(); } }