本文详细介绍Spring框架的核心概念及入门案例，深入讲解IOC（控制反转）原理与应用，包括基于XML配置和注解的方式创建对象及注入属性，同时探讨Bean的管理、作用域、生命周期等高级主题。
目录
1 Spring简介
Spring是轻量级的开源javaee框架，能够解决企业开发的复用性。有两个核心部分：IOC和AOP。Spring有很多特点，如方便解耦，简化开发；方便测试；方便与其他框架进行整合、方便进行事务操作等。
2 Spring入门案例
必须导入下面几个包：
目录结构如下：
创建一个普通类：
User.java:
package com.wzc.spring;
public class User {
public void add(){
System.out.println("add+++++++++++++++");
}
}
配置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">
<!-- 配置User对象创建-->
<bean id="user" class="com.wzc.spring.User"></bean>
</beans>
编写测试代码：
package com.wzc.spring.test;
import com.wzc.spring.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestSpring {
@Test
public void testAdd(){
//1.加载spring配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
//2.获取配置创建对象
User user = context.getBean("user", User.class);
System.out.println(user);
user.add();
}
}
3 IOC
3.1 IOC概念
①IOC即Inversion of Control，控制反转，它将对象创建和对象之间的调用使用Spring框架进行管理
②使用IOC方式可以降低对象之间的耦合度
③上面的入门案例就是使用IOC方法进行实现的
3.2 IOC底层原理
核心：xml解析、工厂模式、反射
IOC过程：
1.配置xml文件，配置创建对象
<bean id="dao" class="com.wzc.UserDao"></bean>
2.有service类和dao类，创建工厂类
class UserFactory{
public static UserDao getDao(){
String classValue = class属性值; //1 xml解析
Class clazz = Class.forName(classValue);//2.通过反射创建对象
return (UserDao)clazz.newInstance();
}
}
3.3 IOC接口
IOC是基于IOC容器完成的，IOC容器底层就是对象工厂
Spring中IOC容器实现的两种方式：
BeanFactory:IOC容器基本实现，Spring内部使用的接口，不提供给开发人员使用(加载配置文件时不会创建对象)
ApplicationContext:BeanFactory接口的子接口，有更多更强大的功能，提供给开发人员使用(加载配置文件时会把配置文件对象进行创建)，有两个实现类
4 IOC操作Bean管理
4.1 Bean管理
Bean的管理主要有两个操作：
Spring操作创建对象、Spring操作注入属性
Bean的管理操作有两个方式：
基于xml文件配置、基于注解实现方式
4.2 基于xml方式创建对象
<bean id="user" class="com.wzc.spring.User"></bean>
在 spring 配置文件中，使用 bean 标签，标签里面添加对应属性实现对象创建
id 属性：唯一标识
class 属性：类全路径（包类路径）
注意：创建对象时候，默认也是执行无参数构造方法完成对象创建，因此在创造bean时需要无参构造器
4.3 基于xml方式注入属性
DI：依赖注入
DI是IOC的一种实现，但注入属性需要在创建对象的基础之上进行完成
4.3.1 使用set方法进行注入
1.创建类，定义属性和对应的set方法
Book.java:
package com.wzc.spring;
public class Book {
private String bname;
private String bauthor;
//创建属性的set方法
public void setBname(String bname){
this.bname = bname;
}
public void setBauthor(String bauthor){
this.bauthor = bauthor;
}
public void printMessage(){
System.out.println("name = " + bname + ", author = " + bauthor);
}
}
2.在spring配置文件配置对象创建和属性注入
bean.xml:
<!--2 set方法注入属性-->
<bean id="book" class="com.wzc.spring.Book">
<!-- 使用property完成属性注入
name:类里面属性的名称
value:向属性注入的值
-->
<property name="bname" value="哈利波特"></property>
<property name="bauthor" value="JK罗琳"></property>
</bean>
4.3.2 使用有参构造器进行注入
1.创建类，定义属性，创造对应属性的有参方法
Orders.java:
package com.wzc.spring;
/**
* 使用有参构造注入
*/
public class Orders {
//属性
private String oname;
private String address;
//有参构造
public Orders(String oname, String address){
this.oname = oname;
this.address = address;
}
public void printMessage(){
System.out.println("name = " + oname + ", address = " + address);
}
}
2.在spring配置文件中进行配置
<!--3 使用有参构造器进行注入 -->
<bean id="order" class="com.wzc.spring.Orders">
<constructor-arg name="oname" value="computer"></constructor-arg>
<constructor-arg name="address" value="China"></constructor-arg>
</bean>
4.4 基于xml方式注入其他类型的属性
4.4.1 注入null
<property name="address">
<null></null>
</property>
4.4.2 属性值带特殊符号
<property name="address">
<value><![CDATA[xxxxx]]></value>
</property>
xxx为所写得整个内容
4.4.3 属性注入-外部bean的注入
1.创建service类和dao类
2.在service调用dao里的方法
3.在spring类中进行配置
UserService .java:
package com.wzc.spring.service;
import com.wzc.spring.dao.UserDao;
public class UserService {
//创建UserDao属性，生成set方法
private UserDao userDao;
public void setUserDao(UserDao userDao){
this.userDao = userDao;
}
public void add(){
System.out.println("service add......");
userDao.update();
}
}
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">
<!-- 创建service和dao对象-->
<bean id="userService" class="com.wzc.spring.service.UserService">
<property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.wzc.spring.dao.UserDaoImpl"></bean>
</beans>
4.4.4 属性注入-内部bean
员工与部门：多对一的关系
部门类
Dept.java:
package com.wzc.spring.bean;
public class Dept {
private String dname;
public void setDname(String dname){
this.dname = dname;
}
@Override
public String toString() {
return "Dept{" +
"dname='" + dname + '\'' +
'}';
}
}
员工类：
Emp.java:
package com.wzc.spring.bean;
public class Emp {
private String ename;
private String gender;
private Dept dept;
public void setName(String ename) {
this.ename = ename;
}
public void setGender(String gender) {
this.gender = gender;
}
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">
<!--内部bean-->
<bean id="emp" class="com.wzc.spring.bean.Emp">
<property name="name" value="luke"></property>
<property name="gender" value="woman"></property>
<!--对象类属性赋值 -->
<property name="dept">
<bean id="dept" class="com.wzc.spring.bean.Dept">
<property name="dname" value="财务部"></property>
</bean>
</property>
</bean>
</beans>
4.4.5 属性注入-级联赋值
方式一：
<bean id="emp1" class="com.wzc.spring.bean.Emp">
<property name="name" value="Jooker"></property>
<property name="gender" value="man"></property>
<property name="dept" ref="dept1"></property>
</bean>
<bean id="dept1" class="com.wzc.spring.bean.Dept">
<property name="dname" value="住宿部"></property>
</bean>
方式二：
需要在Emp类中生成相应的方法
public Dept getDept() {
return dept;
}
<bean id="emp1" class="com.wzc.spring.bean.Emp">
<property name="name" value="Jooker"></property>
<property name="gender" value="man"></property>
<property name="dept" ref="dept1"></property>
<property name="dept.dname" value="金钱部"></property>
</bean>
<bean id="dept1" class="com.wzc.spring.bean.Dept">
<property name="dname" value="技术部"></property>
</bean>
4.4.6 xml注入集合属性
1.创建类，定义数组、list、map、set类型，并生成相应的set方法
Stu.java:
package com.wzc.spring.collectiontype;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Stu {
//1.数组类型属性
private String[] courses;
//2.list集合属性
private List<String> list;
//3.Map集合类型
private Map<String,String> maps;
//4.Set集合类型
private Set<String> set;
public void setCourses(String[] courses) {
this.courses = courses;
}
public void setList(List<String> list) {
this.list = list;
}
public void setMaps(Map<String,String> maps) {
this.maps = maps;
}
public void setSet(Set<String> set) {
this.set = set;
}
public void Message(){
System.out.println(courses);
System.out.println(list);
System.out.println(maps);
System.out.println(set);
}
}
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">
<!--1 集合类型的属性注入-->
<!-- 数组类型属性注入-->
<bean id="stu" class="com.wzc.spring.collectiontype.Stu">
<!-- 数组类型注入 -->
<property name="courses">
<array>
<value>java课程</value>
<value>mysql课程</value>
</array>
</property>
<!-- list 类型注入 -->
<property name="list">
<list>
<value>张三</value>
<value>李四</value>
</list>
</property>
<!-- map类型注入 -->
<property name="maps">
<map>
<entry key="JAVA" value="java"></entry>
<entry key="PHP" value="php"></entry>
</map>
</property>
<!-- set类型注入 -->
<property name="set">
<set>
<value>Mysql</value>
<value>Redis</value>
</set>
</property>
</bean>
</beans>
注意一下两点：
1.在集合中设置对象类型值：
<!--创建多个类型course对象 -->
<bean id="course1" class="com.wzc.spring.collectiontype.Course">
<property name="cname" value="Spring5框架"></property>
</bean>
<bean id="course2" class="com.wzc.spring.collectiontype.Course">
<property name="cname" value="Mybatis框架"></property>
</bean>
<!-- 注入list集合-->
<property name="courseList">
<list>
<ref bean="course1"></ref>
<ref bean="course2"></ref>
</list>
</property>
2.可以将集合部分提取出来
<?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"
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">
<!-- 提取list集合类型属性注入 -->
<util:list id="namelist">
<value>哈哈哈</value>
<value>wodetian</value>
<value>jule</value>
</util:list>
<!-- 提取list集合类型属性注入使用-->
<bean id="stu1" class="com.wzc.spring.collectiontype.Stu">
<property name="list" ref="namelist"></property>
</bean>
</beans>
4.4.7 FactoryBean
Spring有两种类型的bean
1.普通bean：在配置文件中定义bean类型就是返回值类型
2.工厂bean：配置文件中定义的bean类型可以与返回类型不一样
①创建类，让该类作为工厂bean，实现接口FactoryBean
②实现接口中的方法，在实现的方法中定义返回bean的类型
Mybean.java:
package com.wzc.spring.factorybean;
import com.wzc.spring.collectiontype.Course;
import org.springframework.beans.factory.FactoryBean;
public class MyBean implements FactoryBean<Course> {
@Override
public Course getObject() throws Exception {
Course course = new Course();
course.setCname("abc");
return course;
}
@Override
public Class<?> getObjectType() {
return null;
}
@Override
public boolean isSingleton() {
return false;
}
}
<bean id="myBean" class="com.wzc.spring.factorybean.MyBean"></bean>
测试方法
@Test
public void testBean(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
Course course = context.getBean("myBean", Course.class);
System.out.println(course);
}
4.4.8 bean的作用域
1.在spring中默认bean是单实例对象
设置方法bean标签中有scope属性用来设置：
默认值为singleton，代表单实例对象；prototype表示多实例对象
<bean id="myBean" class="com.wzc.spring.factorybean.MyBean" scope="prototype"></bean>
2.singleton和prototype的区别
①singleton表示单实例对象，此时造出的都是同一个对象，地址值相同；prototype表示多实例对象，此时造出的对象地址值不同。
②scope 值为 singleton 时，加载 spring 配置文件时候就会创建单实例对象
scope 值为 prototype 时，不是在加载 spring 配置文件时候创建对象，在调用getBean 方法时候创建多实例对象
4.4.9 bean的生命周期
生命周期：对象从创建到销毁的过程
主要有以下五步：
第一步 执行无参构造器创建bean实例
第二步 调用set方法设置属性值
第三步 执行初始化方法
第四步 获取bean实例对象
第五步 执行销毁方法
Orders.java:
package com.wzc.spring.collectiontype;
public class Orders {
private String oname;
//无参构造器
public Orders(){
System.out.println("第一步 执行无参构造器创建bean实例");
}
public void setOname(String oname) {
this.oname = oname;
System.out.println("第二步 调用set方法设置属性值");
}
public void initMethod(){
System.out.println("第三步 执行初始化方法");
}
public void destMethod(){
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">
<bean id="orders" class="com.wzc.spring.collectiontype.Orders" init-method="initMethod" destroy-method="destMethod">
<property name="oname" value="手机"></property>
</bean>
</beans>
@Test
public void testBean1(){
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
Orders orders = context.getBean("orders", Orders.class);
System.out.println("第四步 获取bean实例对象");
System.out.println(orders);
//手动让bean实例销毁
context.close();
}
还可以配置后置处理器，共有七步
第一步 执行无参构造器创建bean实例
第二步 调用set方法设置属性值
第三步 把bean实例传给bean的后置处理器方postProcessBeforeInitialization
第四步 执行初始化方法
第五步 把bean实例传给bean的后置处理器方postProcessAfterInitialization
第六步 获取bean实例对象
第七步 执行销毁方法
后置处理器类：
package com.wzc.spring.bean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.lang.Nullable;
public class MyBeanPost 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;
}
}
配置方法：
<?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="orders" class="com.wzc.spring.collectiontype.Orders" init-method="initMethod" destroy-method="destMethod">
<property name="oname" value="手机"></property>
</bean>
<!--配置后置处理器 -->
<bean id="myBeanPost" class="com.wzc.spring.bean.MyBeanPost"></bean>
</beans>
4.4.10 自动装配
自动装配：根据指定装配规则(属性名或者属性类型)，Spring自动将匹配的属性值进行注入。
<!--实现自动装配
bean 标签属性 autowire，配置自动装配
autowire 属性常用两个值：
byName 根据属性名称注入 ，注入值 bean 的 id 值和类属性名称一样
byType 根据属性类型注入
-->
<bean id="emp" class="com.wzc.spring.autowire.Emp" autowire="byType">
<!-- <property name="dept" ref="dept"></property>-->
</bean>
<bean id="dept" class="com.wzc.spring.autowire.Dept"></bean>
4.4.11 引入外部属性对象
1.配置Druid连接池
<!-- 直接配置连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql://localhost:3306/test"></property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>
2.建立jdbc.properties文件，配置相应的设置
prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/test
prop.username=root
prop.password=root
3.进行spring配置
<!-- 引入外部属性文件 -->
<context:property-placeholder location="jdbc.properties"></context:property-placeholder>
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${prop.driverClass}"></property>
<property name="url" value="${prop.url}"></property>
<property name="username" value="${prop.username}"></property>
<property name="password" value="${prop.password}"></property>
</bean>
4.5 基于注解方式的Bean管理
注解是代码的特殊标记；注解可以在类、方法、属性上面使用；使用注解可以简化xml文件的配置
格式：@注解名称(属性名称=属性值，属性名称=属性值)
在spring中可以提供下面四个注解来创建对象
@Component
@Service
@Controller
@Repository
以上四个注解都可以创建Bean的实例
4.5.1 基于注解方式创建对象
首先在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: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 http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 开启组件扫描
1.如果扫描多个包，可以用逗号隔开
2.扫描包的上层目录
-->
<context:component-scan base-package="com.wzc.spring"></context:component-scan>
</beans>
然后创建类，在类上添加注解对象
package com.wzc.spring.service;
import org.springframework.stereotype.Component;
//注解中的value可以不写，默认值为类名称，首字母小写
@Component(value = "userService") //<bean id="userService" class=".." >
public class UserService {
public void add(){
System.out.println("add....................");
}
}
运行测试类后，Bean对象已经被创建
4.5.2 组件扫描配置
例子一
<!--se-default-filters="false" 表示现在不使用默认 filter，自己配置 filter
context:include-filter ，设置扫描哪些内容-->
<context:component-scan base-package="com.wzc.spring" use-default-filters="false">
<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
例子二
<!--
下面配置扫描包所有内容
context:exclude-filter： 设置哪些内容不进行扫描
-->
<context:component-scan base-package="com.wzc.spring.service">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"></context:exclude-filter>
</context:component-scan>
4.5.3 基于注解方式实现属性注入
@Autowired：根据属性类型进行自动装配
@Qualifier：根据名称进行注入(入Dao接口可能有多个实现类，所以要根据名称来进行标注)
这两个注解经常一起使用
package com.wzc.spring.service;
import com.wzc.spring.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Service;
//注解中的value可以不写，默认值为类名称，首字母小写
//@Component(value = "userService") //<bean id="userService" class=".." >
@Service
public class UserService {
//定义dao类型
//不需要添加set方法
//添加注入属性注解
@Autowired //根据类型进行注入
@Qualifier(value = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;
public void add(){
System.out.println("service add....................");
userDao.add();
}
@Override
public String toString() {
return "UserService{}";
}
}
package com.wzc.spring.dao;
import org.springframework.stereotype.Repository;
@Repository(value = "userDaoImpl1")
public class UserDaoImpl implements UserDao{
@Override
public void add() {
System.out.println("Dao add................");
}
}
@Resource：可以根据类型注入，也可以根据名称注入
该注解再javax.annotation包中，高版本的java jdk没有
@Resource(name = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;
@Value：注入普通类型属性
@Value(value = "123")
private String name;
参考资料：
[1]尚硅谷spring5
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
