当前位置：首页 > news >正文

Spring-Xml配置

news 2025/8/18 22:02:27

一、Spring 简介

1.简介

文档下载地址：Index of /spring-framework/docs

1.简介

Spring framework 是 Spring 基础框架
学习Spring 家族产品
- Spring framework
- SpringBoot
- SpringCloud
Spring 能用来做什么
- 开发 WEB 项目
- 微服务
- 分布式系统
Spring framework 是 Spring 最基础的框架，是其它框架技术的基础
SpringBoot 是用来做简化开发的，单一项目
SpringCloud 做分布式微服务相关的，拆分大单体项目为小模块项目

2.Spring 概述

2.1 Spring framework 介绍

概述：spring 提供了基础框架，你不必关心框架细节，只需要专注于代码业务逻辑
优点：
- 组件化模块化的：通过很多模块与组件组合成 spring 应用，以后可以通过 Xml 或者注解的方式去操作
- 控制反转（ Inversion of Control (IoC) ）：传统创建对象都是通过认为的new 对象的方式，把控制创建对象的权利转交给Spring
- 依赖注入（Dependency Injection）：自动化的注入属性

3.模块

3.1 Spring 系统架构图

3.2模块介绍

Core Container：核心容器，是Spring 最核心的模块，以后用到的都依赖该模块实现
Aop：面向切面编程，目的是不改变原有代码的前提下对功能进行增强
- Aspects：是Aop 具体实现
Data Access/Integration：数据层
- Data Access：数据访问的
- Data Integration：数据集成
- Transactios：支持事务操作，通过 AOP 来实现，释放我们的双手
Web：WEB 层，SpringMVC 框架的
- Servlet
- Web
Test：做集成测试
- 整合 Junit 做单元测试

二、IOC

1.概述

IOC：Inversion of Control 控制反转，可以让容器负责对象的创建以及销毁操作，对象在容器中叫 bean

2.回顾问题

2.1问题：写了太多与业务无关的代码

耦合度非常高，写了很多和业务无关的代码
不利于项目的升级迭代

思考的解决方案
- 能够直接获取 mapper 接口，而不必去关心底层的获取方式

3.bean 配置

3.1.创建 spring01 项目

项目结构

添加 Spring 依赖

<dependencies>
<!--        添加 spring 依赖--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.17.RELEASE</version></dependency>
<!--        添加 junit 依赖--><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version>
<!--            <scope>test</scope>--></dependency></dependencies>

3.2添加 Student 类

创建空学生类

3.3添加 Spring 配置文件

开始配置 javabean

<?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">
<!--    配置 Student 学生类--><bean id="student" name="stu" class="cn.sycoder.domian.Student"></bean>
</beans>

3.4属性介绍

属性名称	说明
id	给 bean 起名字（定义id 不能重复）
name	给 bean 起别名
class	类全限定类名

4.容器创建

4.1ClassPathXmlApplicationContext

ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
System.out.println(context);

4.2.FileSystemXmlApplicationContext

ApplicationContext ctx = new FileSystemXmlApplicationContext("绝对路径地址");

使用 ClassPathXmlApplicationContext 获取方式会出现如下问题

5.从容器中获取 bean

5.1根据id 获取

ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");//从容器中根据 id 获取 bean 对象
Student stu = (Student)context.getBean("student");//通过别名获取 bean 对象
Student stuByName = (Student)context.getBean("stu");

注意：如果id重复会有如下问题

5.2根据id和类型

ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
final Student bean = context.getBean(Student.class);

注意：使用类型获取的时候，一定要保证容器中只有一个 javabean 对象

4.注意点

bean 的配置spring 是使用反射调用对象的无参构造器实现的。所以必须提供无参构造器，否则会出现如下错误

6.设计模式

6.1单例模式

概述：属于创建型模式，提供了创建对象的最佳方式。单例模式只能有一个单一的类
懒汉式单例模式:需要用的时候，再去把对象创建出来

public class SingleObject {//线程不安全的懒汉式单例模式private static SingleObject instance;public static SingleObject getInstance(){if(instance == null){instance =new SingleObject();}return instance;}}

饿汉式单例模式：不管你有没有，我先创建出来

public class SingleObjectE {//线程不安全的饿汉式单例模式private static SingleObjectE instance = new SingleObjectE();public static SingleObjectE getInstance(){return instance;}
}

6.2工厂模式

概述：也是属于创建型模式，目的也是提供创建对象的最佳方式
静态工厂

public class BeanFactory {public static Student getBean() {return new Student();}public static Object getBean(String name) {if ("Student".equals(name))return new Student();else if("SingleObject".equals(name)) {return new SingleObject();}else{return new Object();}}}

实例工厂

public class BeanFactory {public Object getBean(){return new Student();}
}

7.bean 实例化

bean 交给 spring 创建，底层究竟是怎么创建的？
实例化 bean 三种方式：
- 构造器(常用)
- 静态工厂方法
- 实例工厂方法
- 实现 FactoryBean（最常用）

7.1无参构造器实例化

新建 person 类，底层是通过 clz.getDeclaredClasses() 获取构造器

public class Person {public Person(){}}

配置 Person bean

<bean id="person" class="cn.wjcoder.domian.Person"></bean>

从容器中获取 bean

@Test
public void testConstructorInit(){final ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");Person p = (Person) context.getBean("person");}

注意：修改构造器，添加参数测试，提示找不到无参构造器

7.2静态工厂方法实例化

创建 clintServer 类,提供静态工厂方法

public class ClientServer {//创建自身对象并且私有化private static ClientServer clientServer = new ClientServer();private ClientServer() {}public static ClientServer createInstance(){return clientServer;}
}

配置bean 的 xml

<bean id="clientServer" class="cn.wjcoder.domian.ClientServer" factory-method="createInstance"></bean>

获取 bean

@Testpublic void testFactoryStaticMethodInit(){final ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");final ClientServer bean = context.getBean(ClientServer.class);}

配置关系

7.3实例工厂方法实例化

创建实例工厂类

public class ClientServiceFactory {private static ClientService instance = new ClientService();private ClientServiceFactory(){}public ClientService getInstance(){return instance;}
}

public class ClientService {
}

配置 bean

<!--    配置工厂--><bean id="clientFactory" class="cn.wjcoder.domian.ClientServiceFactory"></bean>
<!--    配置 clientService--><bean id="clientService" factory-bean="clientFactory" factory-method="getInstance"></bean>

获取bean

@Testpublic void testFactoryInstanceMethodInit(){final ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");final ClientService bean = context.getBean(ClientService.class);}

配置关系

7.4实现 FactoryBean实例化

创建员工类

public class Employee {public void check(){System.out.println("检查是否能够拿到员工类对象");}
}

创建员工 factory 类实现 FactoryBean

public class EmployeeFactory implements FactoryBean<Employee> {public Employee getObject() throws Exception {System.out.println("获取 emp 对象");return new Employee();}public Class<?> getObjectType() {return Employee.class;}public boolean isSingleton() {return false;}
}

配置工厂类(并没有直接配置 emp 类)

<bean id="employee" class="cn.wjcoder.domian.EmployeeFactory"></bean>

@Testpublic void testFactoryBeanInit(){final ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");final Employee emp = (Employee)context.getBean("employee");emp.check();}

实现方法说明

isSingleton:如果是 true 返回单例的对象

public boolean isSingleton() {return true;}

getObject:进行对象创建的

public Employee getObject() throws Exception {System.out.println("获取 emp 对象");return new Employee();
}

三、DI

1.概述

概述：Dependency Injection 依赖注入，给对象设置属性，曾经我们需要自己去创建 mapper 对象，才能调用，现在交给 spring 创建，并且使用 DI 注入，直接拿来用，程序员就可以更加关注业务代码而不是创建对象
给对象设置属性方式：
- 构造器
- set 方法
spring 也是通过构造器以及set方法来实现属性设置

2.回顾问题

如果只给了 mapper 对象，那么调用的时候会出现空指针

解决方式：使用 DI 注入，解决方案如下

3.构造器依赖注入

3.1创建学生类

public class Student {
}

3.2创建Mapper 接口以及实现类

创建 Mapper 接口

public interface StudentMapper {void insert(Student stu);int delete(Long id);
}

创建 Mapper 实现类

public class StudentMapperImpl implements StudentMapper{public void insert(Student stu) {System.out.println("保存学生信息");}
public int delete(Long id) {System.out.println("删除id="+id+"的学生信息");return 1;}
}

将 Mapper 交给容器管理

<bean id="studentMapper" class="cn.wjcoder.di.mapper.StudentMapperImpl"></bean>

3.3创建 service 接口以及实现类

创建 service 接口

public interface IStudentService {void insert(Student stu);
int delete(Long id);
}

创建 service 实现类

public class StudentServiceImpl implements IStudentService {
private StudentMapper mapper;
public void insert(Student stu) {mapper.insert(stu);}
public int delete(Long id) {return mapper.delete(id);}
}

将 service 交给容器管理

<bean id="iStudentService" class="cn.wjcoder.di.service.impl.StudentServiceImpl"></bean>

3.4如果没有使用DI注入直接调用

会产生如下问题

4.5配置构造器注入属性

配置 service 构造器

public class StudentServiceImpl implements IStudentService {private StudentMapper mapper;public StudentServiceImpl(StudentMapper mapper){this.mapper = mapper;}public void insert(Student stu) {mapper.insert(stu);}public int delete(Long id) {return mapper.delete(id);}
}

配置 xml

<!--    配置 service--><bean id="iStudentService" class="cn.wjcoder.di.service.impl.StudentServiceImpl"><constructor-arg name="mapper" ref="studentMapper"></constructor-arg></bean>
<!--    配置 mapper--><bean id="studentMapper" class="cn.wjcoder.di.mapper.StudentMapperImpl"></bean>

注意：

name:构造器的参数名称
ref:配置文件中其它 bean 的名称
图示如下

3.6构造器配置多个引用类型参数

配置service

public class StudentServiceImpl implements IStudentService {private StudentMapper mapper;private UserMapper userMapper;public StudentServiceImpl(StudentMapper mapper,UserMapper userMapper){this.mapper = mapper;this.userMapper = userMapper;}public void insert(Student stu) {mapper.insert(stu);}public int delete(Long id) {userMapper.delete(id);return mapper.delete(id);}
}

创建mapper

public interface UserMapper {int delete(Long id);
}

创建mapper实现类

public class UserMapperImpl implements UserMapper{public int delete(Long id) {System.out.println("删除id="+id+"的用户信息");return 1;}
}

配置bean

<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-->
<bean id="iStudentService" class="cn.wjcoder.di.service.impl.StudentServiceImpl"><constructor-arg name="mapper" ref="studentMapper"></constructor-arg><constructor-arg name="userMapper" ref="userMapper"></constructor-arg>
</bean>
<!--    配置学生mapper-->
<bean id="studentMapper" class="cn.wjcoder.di.mapper.StudentMapperImpl"></bean>
<!--    配置用户mapper-->
<bean id="userMapper" class="cn.wjcoder.di.mapper.UserMapperImpl"></bean>
</beans>

3.7构造器配置多个基本数据类型参数

配置service

public class StudentServiceImpl implements IStudentService {private String name;private int age;private StudentMapper mapper;private UserMapper userMapper;public StudentServiceImpl(String name,int age,StudentMapper mapper,UserMapper userMapper){this.name = name;this.age = age;this.mapper = mapper;this.userMapper = userMapper;}public void insert(Student stu) {mapper.insert(stu);}public int delete(Long id) {System.out.println( name+":"+age);userMapper.delete(id);return mapper.delete(id);}
}

配置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">
<!--    配置 service--><bean id="iStudentService" class="cn.sycoder.di.service.impl.StudentServiceImpl"><constructor-arg name="userMapper" ref="userMapper"></constructor-arg><constructor-arg name="mapper" ref="studentMapper"></constructor-arg><constructor-arg type="int" value="18"></constructor-arg><constructor-arg type="java.lang.String" value="sy"></constructor-arg></bean>
<!--    配置学生mapper--><bean id="studentMapper" class="cn.sycoder.di.mapper.StudentMapperImpl"></bean>
<!--    配置用户mapper--><bean id="userMapper" class="cn.sycoder.di.mapper.UserMapperImpl"></bean>
</beans>

这种方式会存在参数覆盖的问题，解决方式，删除 type 添加 index 属性

<?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--><bean id="iStudentService" class="cn.sycoder.di.service.impl.StudentServiceImpl"><constructor-arg name="userMapper" ref="userMapper"></constructor-arg><constructor-arg name="mapper" ref="studentMapper"></constructor-arg><constructor-arg index="2" value="18"></constructor-arg><constructor-arg index="1" value="1"></constructor-arg><constructor-arg type="java.lang.String" value="sy"></constructor-arg></bean>
<!--    配置学生mapper--><bean id="studentMapper" class="cn.sycoder.di.mapper.StudentMapperImpl"></bean>
<!--    配置用户mapper--><bean id="userMapper" class="cn.sycoder.di.mapper.UserMapperImpl"></bean>
</beans>

4.setter依赖注入

使用 set 方法实现属性的注入
使用 property 属性
- name:属性名称
- value:直接给值
- ref:其它bean的引用

4.1创建员工类

public class Employee {
}

4.2创建 mapper 接口以及实现类

mapper 接口

public interface EmployeeMapper {int delete(Long id);
}

mapper 实现类

public class EmployeeMapperImpl implements EmployeeMapper {public int delete(Long id) {System.out.println("删除当前员工id:"+id);return 1;}
}

4.3创建 servie 接口以及实现类

创建 service 接口

public interface IEmployeeService {int delete(Long id);
}

创建 service 接口实现类

public class EmployeeServiceImpl implements IEmployeeService {
private EmployeeMapper mapper;
public int delete(Long id) {return mapper.delete(id);}
}

4.4配置 setter 注入

配置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"><!--    配置mapper实现类-->
<!--    配置mapper--><bean id="empMapper" class="cn.sycoder.di.setter.mapper.EmployeeMapperImpl"></bean>
<!--    配置service--><bean id="empService" class="cn.sycoder.di.setter.service.impl.EmployeeServiceImpl"></bean>
</beans>

service 实现中提供 mapper 的setter 方法

public class EmployeeServiceImpl implements IEmployeeService {
private EmployeeMapper employeeMapper;
public int delete(Long id) {return employeeMapper.delete(id);}public void setEmployeeMapper(EmployeeMapper employeeMapper){this.employeeMapper = employeeMapper;}
}

修改 beans.xml 通过 setter 注入

<?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"><!--    配置mapper实现类-->
<!--    配置mapper--><bean id="empMapper" class="cn.sycoder.di.setter.mapper.EmployeeMapperImpl"></bean>
<!--    配置service--><bean id="empService" class="cn.sycoder.di.setter.service.impl.EmployeeServiceImpl"><property name="employeeMapper" ref="empMapper"></property></bean>
</beans>

获取 service 执行 delete 方法

@Testpublic void testSetDi(){final ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("DiSetterBeans.xml");final IEmployeeService empService = (IEmployeeService) context.getBean("empService");empService.delete(2L);}

setter 注入过程分析

4.5配置多个 setter 方法注入多个属性

给service 添加新的属性以及新的setter方法

public class EmployeeServiceImpl implements IEmployeeService {
private EmployeeMapper employeeMapper;
private UserMapper userMapper;
public int delete(Long id) {return employeeMapper.delete(id);}
public void setEmployeeMapper(EmployeeMapper employeeMapper){System.out.println("=======使用 setter 注入=======");this.employeeMapper = employeeMapper;}
public void setUserMapper(UserMapper mapper){this.userMapper = mapper;}
}

配置 userMapper 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"><!--    配置mapper实现类-->
<!--    配置mapper--><bean id="empMapper" class="cn.sycoder.di.setter.mapper.EmployeeMapperImpl"></bean>
<!--    配置service--><bean id="empService" class="cn.sycoder.di.setter.service.impl.EmployeeServiceImpl"><property name="employeeMapper" ref="empMapper"></property></bean>
<!--    配置 userMapper--><bean id="userMapper" class="cn.sycoder.di.constructor.mapper.StudentMapperImpl"></bean>
</beans>

通过 setter 注入

<?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"><!--    配置mapper实现类-->
<!--    配置mapper--><bean id="empMapper" class="cn.sycoder.di.setter.mapper.EmployeeMapperImpl"></bean>
<!--    配置service--><bean id="empService" class="cn.sycoder.di.setter.service.impl.EmployeeServiceImpl"><property name="employeeMapper" ref="empMapper"></property><property name="userMapper" ref="userMapper"></property></bean>
<!--    配置 userMapper--><bean id="userMapper" class="cn.sycoder.di.constructor.mapper.UserMapperImpl"></bean>
</beans>

获取 service 操作delete 方法

@Testpublic void testSetterSDi(){final ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("DiSetterBeans.xml");final IEmployeeService empService = (IEmployeeService) context.getBean("empService");empService.delete(2L);}

4.6使用 setter 注入简单类型

修改 service 类，提供两个属性 int age = 18,String name = "sy"

public class EmployeeServiceImpl implements IEmployeeService {
private EmployeeMapper employeeMapper;
private UserMapper userMapper;private String name;private int age;public void setName(String name){this.name = name;}public void setAge(int age){this.age = age;}
public int delete(Long id) {System.out.println(name + ":" + age);userMapper.delete(id);return employeeMapper.delete(id);}
public void setEmployeeMapper(EmployeeMapper employeeMapper){System.out.println("=======EmployeeMapper使用 setter 注入=======");this.employeeMapper = employeeMapper;}
public void setUserMapper(UserMapper mapper){System.out.println("=======UserMapper使用 setter 注入=======");this.userMapper = mapper;}
}

配置 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"><!--    配置mapper实现类-->
<!--    配置mapper--><bean id="empMapper" class="cn.sycoder.di.setter.mapper.EmployeeMapperImpl"></bean>
<!--    配置service--><bean id="empService" class="cn.sycoder.di.setter.service.impl.EmployeeServiceImpl"><property name="employeeMapper" ref="empMapper"></property><property name="userMapper" ref="userMapper"></property><property name="name" value="sy"></property><property name="age" value="18"></property></bean>
<!--    配置 userMapper--><bean id="userMapper" class="cn.sycoder.di.constructor.mapper.UserMapperImpl"></bean>
</beans>

可能出现的问题

4.7setter 注入总结

对于引用数据类型来说使用

<property name="" ref=""></property>

对于简单数据类型

*<property name="" value=""></property>

5.集合注入

List，Set，Map，Array，Properties

5.1添加CollectiosDemo类

1.添加CollectiosDemo类1.添加CollectiosDemo类public class CollectionsDemo {private List<Integer> list;private Map<String,String> map;private Set<String> set;private Properties properties;private int[] arr;public void print(){System.out.println("list:"+list);System.out.println("map:"+map);System.out.println("set:"+set);System.out.println("properties:"+properties);System.out.println("arr:"+ Arrays.toString(arr));}public void setList(List<Integer> list) {this.list = list;}public void setMap(Map<String, String> map) {this.map = map;}public void setSet(Set<String> set) {this.set = set;}public void setProperties(Properties properties) {this.properties = properties;}public void setArr(int[] arr) {this.arr = arr;}
}

5.2配置 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="collectionsDemo" class="cn.sycoder.collections.CollectionsDemo">
<!--        注入 list--><property name="list"><list><value>1</value><value>2</value><value>3</value></list></property><property name="map"><map><entry key="name" value="sy"/><entry key ="age" value="18"/></map></property><property name="set"><set><value>just some string</value><value>just string</value></set></property><property name="properties"><props><prop key="url">@example.org</prop><prop key="user">root</prop><prop key="password">123456</prop></props></property><property name="arr"><array><value>2</value><value>2</value><value>2</value></array></property></bean>
</beans>

如果不提供setter 方法会出现如下错误

6.自动装配

6.1概述

概述：IOC容器根据bean所依赖的属性，自动查找并进行自动装配。

6.2分类

不启用自动装配
byName 通过名称
byType 通过类型
constructor 通过构造器

6.3实操

准备工作

public class EmployeeService {private EmployeeMapperImpl employeeMapper;public int delete(Long id) {return employeeMapper.delete(id);}public void setEmployeeMapper(EmployeeMapperImpl employeeMapper){System.out.println("=======EmployeeMapper使用 setter 注入=======");this.employeeMapper = employeeMapper;}
}
public class EmployeeMapperImpl{public int delete(Long id) {System.out.println("删除当前员工id:"+id);return 1;}
}

配置 bean 并且通过 bype 自动装配

<?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="empService" class="cn.sycoder.autowired.EmpService" autowire="byType"></bean><bean id="empMapperImpl" class="cn.sycoder.autowired.EmpMapperImpl"></bean>

</beans>

配置 bean 并且通过 byName 自动装配

<?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="empService" class="cn.sycoder.autowired.EmpService" autowire="byName"></bean><bean id="empMapperImpl" class="cn.sycoder.autowired.EmpMapperImpl"></bean>

</beans>

通过名称和类型的自动装配
- byName
  - 使用 id 或者是 name 别名
  - 如果自动注入时，有多个相同对象，只能使用 byName
- byType
  - 根据类型注入
  - 通过 byType 注入要保证容器中只有一个 bean 对象，否则会出现如下错误

注意：
- 自动注入的优先级是低于 setter 和构造器注入的
- 自动注入只能用于引用类型，不能用于基本数据类型
- 推荐使用 byType 方式实现自动注入
- 注入流程
  - byType 根据 getClass 去注入
  - byName 根据属性名称去注入

7.bean scopes

常见的作用域

作用域	说明
singleton	单例的
prototype	多例
request	请求
session	会话

单例 singleton

修改对象变成多个实例的

注意：容器模式就是以单例的方式创建对象的，如果需要修改成非单例，使用 scope 属性修改即可
以后开发中适合将那些bean对象交给 spring 管理
- 持久层 mapper
- 业务层 service
- 控制层 controller
单例bean会出现线程安全吗
- 判断bean 对象是否存储数据，如果用来存储数据了，会导致线程安全问题
- 使用局部变量做存储，方法调用结束就销毁了，所以不存在线程安全问题

8.bean 生命周期

8.1概述

概述：生命周期就是一个对象从出生到死亡的过程

8.2使用用户类观察生命周期

创建用户类

public class User {private String name;public User(){System.out.println("构造器执行====");}
public void setName(String name) {System.out.println("调用 set 方法");this.name = name;}public void init(){System.out.println("调用 init 方法");}public void destroy(){System.out.println("调用销毁方法");}
}

配置 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="user" class="cn.sycoder.lifecycle.User" init-method="init" destroy-method="destroy"><property name="name" value="sy"></property></bean>
</beans>

获取 bean 出现如下问题，没有打印销毁方法
- 原因：
  - spring ioc 容器是运行在 jvm 虚拟机中的
  - 执行 test 方法后 jvm 虚拟机开启，spring 加载配置文件创建 bean 对象，调用构造器以及 init 方法
  - test 方法执行完毕的时候， jvm 退出，spring ioc 容器来不及关闭销毁 bean，所以没有去调用 destroy 方法

解决办法，手动关闭容器

5.3BeanPostProcessor

自定义自己 bean 处理器

public class MyBeanPostProcessor  implements BeanPostProcessor{public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {//bean 前置处理器System.out.println("bean 的前置处理器");return bean;}public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {System.out.println("bean 的后置处理器");//bean 后置处理器return bean;}
}

配置 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="user" class="cn.sycoder.lifecycle.User" init-method="init" destroy-method="destroy"><property name="name" value="sy"></property></bean><bean class="cn.sycoder.lifecycle.MyBeanPostProcessor"></bean>
</beans>

5.4生命周期总结

bean 对象创建（调用无参构造器）
设置属性通过 setter 方法
init 方法前调用 bean 的前置处理器
bean 的 init 方法
bean 的后置处理器
对象可以正常使用
destroy 销毁方法
ioc 容器关闭
jvm 虚拟机的退出

四、容器执行点

1.整合 druid 连接池

添加依赖

<dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.2.8</version>
</dependency>

1.1硬编码方式整合

新建德鲁伊配置

<?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="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="username" value="root"></property><property name="password" value="123456"></property><property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property><property name="url" value="jdbc:mysql://localhost:3306/mybatis"></property></bean>
</beans>

注意：属性是通过 set 方法注入进来的

1.2使用占位符获取连接数据

建立 db.properties 配置文件

username=root
password=123456
driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis

配置引用db.properties

 <bean id="dataSource1" class="com.alibaba.druid.pool.DruidDataSource"><property name="username" value="${username}"></property><property name="password" value="${password}"></property><property name="driverClassName" value="${driverClassName}"></property><property name="url" value="${url}"></property></bean>
<!--    获取db.properties 配置文件--><bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"><property name="location" value="db.properties"></property></bean>

引入 db.properties 缩写

<context:property-placeholder location="db.properties"/>

1.3注意事项

<context:property-placeholder location="db.properties"/> 使用这个标签加载配置会加载到电脑系统配置
解决方式
- 给配置文件加上前缀变量

jdbc.username=root
jdbc.password=123456
jdbc.driverClassName=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis
username=123

添加属性

<context:property-placeholder system-properties-mode="NEVER" location="db.properties"/>

加载多个配置文件可以用 * 代替

<context:property-placeholder system-properties-mode="NEVER" location="*.properties"/>

2.容器总结

2.1容器层级结构

按两次 shift 搜索 BeanFactory

按 ctrl + h 查看继承结构

2.2创建容器

BeanFactory 是容器顶层接口
ApplicationContext 核心接口
AbstractApplicationContext 抽象类，提供了获取 bean 以及加载资源的功能
ClassPathXmlApplicationContext 装载bean的，做初始化的

2.3bean 配置

<bean id="user" class="cn.sycoder.lifecycle.User" init-method="init" destroy-method="destroy" scope="默认单例" autowire="byName" lazy-init="false"><property name="name" value="sy"></property>
</bean>

lazy-init:如果开启懒加载，默认是调用时才创建bean
init-method:初始化方法
destroy-method:销毁方法
scope:作用域，单例，原型
autowire：自动注入
id:代表名称，必须唯一
class:全限定类名