Spring01:概述、工厂模式解耦、Spring中的IOC
- 四天课程安排
- 第一天：Spring框架的概述、Spring中基于XML的IOC配置
- 第二天： Spring中基于注解的IOC和IOC的案例（单表增删改查，持久层随意）
- 第三天：Spring中的AOP和基于XML以及注解的AOP配置
- 第四天：Spring中的JDBCTemplate及Spring事务控制
- 今日内容
- Spring的概述
- Spring是什么
- Spring的两大核心--AOC和IOP
- Spring的发展历程和优势
- Spring的体系结构
- 程序的耦合及解耦
- 以往案例中的问题
- 工厂模式解耦
- IOC的概念和Spring中的IOC
- Spring中基于xml的IOC环境搭建
- 依赖注入（Dependency Injection，DI）
- 作业：
一、Spring的概述
1、概述--spring.io
Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：
反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 Spring
MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多
著名的第三方框架和类库，逐渐成为使用最多的 Java EE 企业应用开源框架。
三层架构
2、Spring的发展历程
3、Spring的优势
- 解耦：今天、明天
- AOP面向切面编程：Aspect Oriented Programming第三天
- 声明式事务：第四天
- 方便程序的测试：第二天
- 方便集成各种优秀框架：第三天的ssm整合
- 降低JavaEE API的使用难度：第四天的JDBC、Spring和JavaMail的整合
- Java源码是经典学习范例
4、spring的体系结构
- Mybatis基于maven工程进行构建
- 官网有maven的坐标
- 资料提供源码dist、文档docs、约束scheme
1 2 4均需要核心容器的支持
二、程序的耦合及解耦
1、编写jdbc的工程代码用于分析程序的耦合
package com.itheima.jdbc;
import java.sql.*;
/**
* 程序的耦合
*/
public class JdbcDemo1 {
public static void main(String[] args) throws Exception {
//1.注册驱动
//不导包，没有依赖会产生编译器异常
//没有MySQL驱动就无法编译
DriverManager.registerDriver(new com.mysql.jdbc.Driver());
//2.获取连接
Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/eesy_spring","root","root");
//3.获取操作数据库的预处理对象
PreparedStatement pstm = connection.prepareStatement("select * from account");
//4.执行SQL，得到结果集
ResultSet rs = pstm.executeQuery();
//5.遍历结果集
while(rs.next()){
System.out.println(rs.getString("name"));
}
//6.释放资源
rs.close();
pstm.close();
connection.close();
}
}2、程序的耦合和解耦的思路分析1
- 耦合：程序间的依赖关系，包括
- 类之间的依赖
- 方法间的依赖
- 解耦：降低程序间的依赖关系
- 实际开发中应该做到：
- 编译期不依赖
- 运行时才依赖
- 解耦的思路：
- 第一步：使用反射创建对象（只依赖于字符串，而不依赖于驱动类），而避免使用new关键字
- 缺点Class.forName("com.mysql.jdbc.Driver");更换为其他数据库时太麻烦
- 第二步：通过读取配置文件获取要创建的对象的全限定类名
- 需要解决：表现层调业务层、业务层调持久层，使代码的独立性很差
3、编写工厂类和配置文件
Bean.properties
accountService=com.itheima.service.impl.AccountServiceImpl
accountDao=com.itheima.dao.impl.AccountDaoImplpackage com.itheima.factory;
/**
* 一个创建Bean对象的工厂
*
* Bean：在计算机英语中，有可重用组件的含义
* Java Bean：用Java语言编写的可重用组件
* 容易看成实体类，实际上不相等，＞
* 它就是用于创建service和dao对象的
*
* 第一个：需要一个配置文件来配置service和dao
* 配置的内容：唯一标识=全限定类名（key=value）
* 第二个：通过读取配置文件中配置的内容，反射创建对象
*
* 配置文件可以使xml或properties（配置结构更简单）
*/
public class BeanFactory {
}4、工厂模式解耦
package com.itheima.factory;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
/**
* 一个创建Bean对象的工厂
*
* Bean：在计算机英语中，有可重用组件的含义
* Java Bean：用Java语言编写的可重用组件
* 容易看成实体类，实际上不相等，＞
* 它就是用于创建service和dao对象的
*
* 第一个：需要一个配置文件来配置service和dao
* 配置的内容：唯一标识=全限定类名（key=value）
* 第二个：通过读取配置文件中配置的内容，反射创建对象
*
* 配置文件可以使xml或properties（配置结构更简单）
*/
public class BeanFactory {
//定义一个Properties对象
private static Properties props;
//使用静态代码块为Properties对象赋值
static{
try {
//实例化对象
props = new Properties();
//获取properties的流对象
InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("Bean.properties");
props.load(in);
} catch (IOException e) {
throw new ExceptionInInitializerError("初始化properties失败");
}
}
/**
* 根据Bean的名称获取bean对象
* @param beanName
* @return
*/
public static Object getBean(String beanName){
Object bean = null;
try {
String beanPath = props.getProperty(beanName);
System.out.println(beanPath);
//反射
bean = Class.forName(beanPath).newInstance();
}catch (Exception e) {
e.printStackTrace();
}
return bean;
}
}package com.itheima.ui;
import com.itheima.factory.BeanFactory;
import com.itheima.service.IAccountService;
import com.itheima.service.impl.AccountServiceImpl;
/**
* 模拟一个表现层，用于调用业务层
*/
public class Client {
public static void main(String[] args) {
//IAccountService as = new AccountServiceImpl();
IAccountService as = (IAccountService)BeanFactory.getBean("accountService");
as.saveAccount();
}
}package com.itheima.service.impl;
import com.itheima.dao.IAccountDao;
import com.itheima.dao.impl.AccountDaoImpl;
import com.itheima.factory.BeanFactory;
import com.itheima.service.IAccountService;
/**
* 账户的业务层实现类
*/
public class AccountServiceImpl implements IAccountService {
//业务层调用持久层
//避免写new
//private IAccountDao accountDao = new AccountDaoImpl();
private IAccountDao accountDao = (IAccountDao)BeanFactory.getBean("accountDao");
@Override
public void saveAccount() {
accountDao.saveAccount();
}
}5、分析工厂模式中的问题并改造
- 打印五次有五次实例（多例对象）
- 单例：只有一个实例；【推荐】将成员变量放到方法内部，即可实现变量每次的初始化
6、工厂模式解耦的升级版
package com.itheima.factory;
import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
/**
* 一个创建Bean对象的工厂
*
* Bean：在计算机英语中，有可重用组件的含义
* Java Bean：用Java语言编写的可重用组件
* 容易看成实体类，实际上不相等，＞
* 它就是用于创建service和dao对象的
*
* 第一个：需要一个配置文件来配置service和dao
* 配置的内容：唯一标识=全限定类名（key=value）
* 第二个：通过读取配置文件中配置的内容，反射创建对象
*
* 配置文件可以使xml或properties（配置结构更简单）
*/
public class BeanFactory {
//定义一个Properties对象
private static Properties props;
//定义一个map，用于存放创建的对象，我们将其称之为容器
private static Map<String,Object> beans;
//使用静态代码块为Properties对象赋值
static{
try {
//实例化对象
props = new Properties();
//获取properties的流对象
InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("Bean.properties");
props.load(in);
//实例化容器
beans = new HashMap<>();
//取出配置文件中所有的key
Enumeration keys = props.keys();
//遍历枚举
while(keys.hasMoreElements()){
//取出每个key
String key = keys.nextElement().toString();
//根据key获取value
String beanPath = props.getProperty(key);
//反射创建对象
Object value = Class.forName(beanPath).newInstance();
//把key和value存入容器之中
beans.put(key,value);
}
} catch (Exception e) {
throw new ExceptionInInitializerError("初始化properties失败");
}
}
/**
* 根据Bean的名称获取bean对象
* @param beanName
* @return
*/
public static Object getBean(String beanName){
return beans.get(beanName);
}
}package com.itheima.ui;
import com.itheima.dao.IAccountDao;
import com.itheima.factory.BeanFactory;
import com.itheima.service.IAccountService;
import com.itheima.service.impl.AccountServiceImpl;
/**
* 模拟一个表现层，用于调用业务层
*/
public class Client {
private IAccountDao accountDao = (IAccountDao)BeanFactory.getBean("accountDao");
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
IAccountService as = (IAccountService)BeanFactory.getBean("accountService");
System.out.println(as);
as.saveAccount();
}
}
}package com.itheima.service.impl;
import com.itheima.dao.IAccountDao;
import com.itheima.dao.impl.AccountDaoImpl;
import com.itheima.factory.BeanFactory;
import com.itheima.service.IAccountService;
/**
* 账户的业务层实现类
*/
public class AccountServiceImpl implements IAccountService {
//业务层调用持久层
//避免写new
//private IAccountDao accountDao = new AccountDaoImpl();
private IAccountDao accountDao;
//private int i = 1;
public void saveAccount() {
accountDao = (IAccountDao)BeanFactory.getBean("accountDao");
int i = 1;
//如果想每次调用得到的是新值，则需要定义到方法内部
accountDao.saveAccount();
System.out.println(i);
i++;
}
}三、IOC的概念和Spring中的IOC
1、ioc的概念和作用
Inversion of Control
两种创建对象的方式
private IAccountDao accountDao = new AccountDaoImpl();
private IAccountDao accountDao = (IAccountDao)BeanFactory.getBean("accountDao");主动new对象：
控制反转，被动接收
对象创建的控制权被动转移给工厂，削减程序的耦合
2、spring中的Ioc前期准备
作用：解决程序间的依赖关系，解耦
3、spring基于XML的IOC环境搭建和入门
<?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 id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>
<bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl"></bean>
</beans>package com.itheima.ui;
import com.itheima.dao.IAccountDao;
import com.itheima.service.IAccountService;
import com.itheima.service.impl.AccountServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
*
*/
public class Client {
/**
* 获取Spring的IOC核心容器，并根据id获取对象
* @param args
*/
public static void main(String[] args) {
//1.获取核心容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//2.根据id获取bean对象---两种方式
IAccountService as = (IAccountService) ac.getBean("accountService");
IAccountDao adao = ac.getBean("accountDao",IAccountDao.class);
System.out.println(as);
System.out.println(adao);
}
}4、ApplicationContext的三个实现类
如何找到接口的实现类
* Application的三个常用实现类
* ClassPathXmlApplicationContext：可以加载类路径下的配置文件，要求配置文件必须在类路径下，不在的加载不了【更常用】
* FileSystemApplicationContext：可以加载磁盘任意路径下的配置文件（必须有访问权限）
* ※ new FileSystemXmlApplicationContext ("D:\\IdeaProjects\\06Spring\\day03_eesy_03Spring \\src\\main\\resources\\bean.xml");
* AnnotationConfigApplicationContext：是用于读取注解创建容器的，为明天的内容
5、BeanFactory和ApplicationContext的区别【创建的时间不同：立即加载和延迟加载】
package com.itheima.ui;
import com.itheima.dao.IAccountDao;
import com.itheima.service.IAccountService;
import com.itheima.service.impl.AccountServiceImpl;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
/**
*
*/
public class Client {
/**
* 获取Spring的IOC核心容器，并根据id获取对象
* Application的三个常用实现类
* ClassPathXmlApplicationContext：可以加载类路径下的配置文件，要求配置文件必须在类路径下，不在的加载不了
* FileSystemApplicationContext：可以加载磁盘任意路径下的配置文件（必须有访问权限）
* AnnotationConfigApplicationContext：是用于读取注解创建容器的，为明天的内容
* @param args
*/
public static void main(String[] args) {
/* //1.获取核心容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//2.根据id获取bean对象---两种方式
IAccountService as = (IAccountService) ac.getBean("accountService");
IAccountDao adao = ac.getBean("accountDao",IAccountDao.class);
System.out.println(as);
System.out.println(adao);*/
//***---BeanFactory***///
Resource resource = new ClassPathResource("bean.xml");
BeanFactory factory = new XmlBeanFactory(resource);
IAccountService as = (IAccountService) factory.getBean("accountService");
IAccountDao adao = factory.getBean("accountDao",IAccountDao.class);
System.out.println(as);
System.out.println(adao);
}
}核心容器的两个接口引发出的问题
- ApplicationContext：在构建核心容器时，创建对象采取的策略是立即加载的方式；即只要一读取完配置文件，马上就创建配置文件中配置的对象【单例对象适用】※常用此接口定义容器对象
- 类视图找到的BeanFactory：在构建核心容器时，创建对象采取的策略是延迟加载的方式。也就是说，什么时候根据id读取对象了，什么时候才真正创建对象。【多例对象适用】【顶层接口】
6、spring中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">
<!--把对象的创建交给Spring管理-->
<!--
Spring对Bean的管理细节
1、创建Bean的三种方式
2、Bean对象的作用范围
3、Bean对象的生命周期
-->
<!--创建Bean的三种方式-->
<!--第一种方式：使用默认构造函数创建
在Spring的配置文件中使用bean标签 ，配以id和class属性后，且没有其他属性和标签时
采用的就是默认构造函数创建Bean对象，此时如果没有构造函数，则对象无法创建
-->
<!--<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>-->
<!--jar中只有class文件，获取有些对象的返回值，则需要采用第二种或第三种创建对象-->
<!--第二种方式：使用普通工厂中的方法创建对象（使用类中的方法创建对象，并存入Spring容器）-->
<bean id="instanceFactory" class="com.itheima.factory.InstancsFactory"></bean>
<bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>
<!--第三种方式：使用静态工厂中的静态方法创建对象，并存入Spring容器-->
<!--
<bean id="accountService" class="com.itheima.factory.StaticFactory" factory-method="getAccountService"></bean>
-->
</beans>package com.itheima.ui;
import com.itheima.service.IAccountService;
import com.itheima.service.impl.AccountServiceImpl;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
/**
*
*/
public class Client {
/**
* 获取Spring的IOC核心容器，并根据id获取对象
* @param args
*/
public static void main(String[] args) {
//1.获取核心容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//2.根据id获取bean对象---两种方式
IAccountService as = (IAccountService) ac.getBean("accountService");
System.out.println(as);
as.saveAccount();
}
}
7、spring中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的作用范围调整
默认是单例
通过bean标签的scope属性，调整bean的作用范围
取值：（单例和多例最常用）
singleton：单例的（默认值）
prototype：多例的
request：作用于web应用的请求范围
session：作用于web应用的会话范围
global-session：作用于集群环境的全局会话范围，当不是集群环境时，就是session
-->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl" scope="prototype"></bean>
</beans>8、spring中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">
<!--把对象的创建交给Spring管理-->
<!--
Spring对Bean的管理细节
1、创建Bean的三种方式
2、Bean对象的作用范围
3、Bean对象的生命周期
-->
<!--创建Bean的三种方式-->
<!--第一种方式：使用默认构造函数创建
在Spring的配置文件中使用bean标签 ，配以id和class属性后，且没有其他属性和标签时
采用的就是默认构造函数创建Bean对象，此时如果没有构造函数，则对象无法创建
-->
<!--<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>-->
<!--jar中只有class文件，获取有些对象的返回值，则需要采用第二种或第三种创建对象-->
<!--第二种方式：使用普通工厂中的方法创建对象（使用类中的方法创建对象，并存入Spring容器）-->
<!--<bean id="instanceFactory" class="com.itheima.factory.InstancsFactory"></bean>
<bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>-->
<!--第三种方式：使用静态工厂中的静态方法创建对象，并存入Spring容器-->
<!--
<bean id="accountService" class="com.itheima.factory.StaticFactory" factory-method="getAccountService"></bean>
-->
<!--bean的作用范围调整
默认是单例
通过bean标签的scope属性，调整bean的作用范围
取值：（单例和多例最常用）
singleton：单例的（默认值）
prototype：多例的
request：作用于web应用的请求范围
session：作用于web应用的会话范围
global-session：作用于集群环境的全局会话范围，当不是集群环境时，就是session
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl" scope="prototype"></bean>
-->
<!--bean对象的生命周期
区分单例对象/多例对象
单例对象
出生：当容器创建时，对象出生
存活：只要容器还在，对象就一直活着
死亡：容器销毁，对象消亡
总结：单例对象的生命周期和容器相同
多例对象
出生：当使用对象时，Spring框架为我们创建
存活：对象在使用过程中一直存活
死亡：当对象长时间不用且没有其他对象引用时，由Java的垃圾回收期回收
-->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl" scope="prototype"
init-method="init" destroy-method="destroy"></bean>
</beans>package com.itheima.ui;
import com.itheima.service.IAccountService;
import com.itheima.service.impl.AccountServiceImpl;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
/**
*
*/
public class Client {
/**
* 获取Spring的IOC核心容器，并根据id获取对象
* @param args
*/
public static void main(String[] args) {
//1.获取核心容器对象
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//2.根据id获取bean对象---两种方式
IAccountService as = (IAccountService) ac.getBean("accountService");
as.saveAccount();
//没有调用销毁时，容器已经消失了
//可以手动关闭容器
ac.close();
}
}
package com.itheima.service.impl;
import com.itheima.service.IAccountService;
/**
* 账户的业务层实现类
*/
public class AccountServiceImpl implements IAccountService {
//private IAccountDao accountDao = null;
public AccountServiceImpl(){
System.out.println("service对象创建了");
}
public void init(){
System.out.println("对象初始化了");
}
public void destroy(){
System.out.println("对象销毁了");
}
public void saveAccount() {
System.out.println("service中的saveAccount方法执行了");
}
}四、依赖注入
1、概念
依赖注入：Dependency Injection
IOC的作用：
降低/削减程序间的耦合程度（依赖关系）
依赖关系的管理
以后都交给了Spring维护
在当前类中需要用到其他类的对象，由Spring为我们提供，我们只需要在配置文件中说明
依赖关系的维护就称之为“依赖注入”
依赖注入：
能注入的数据由三类：
基本类型和String
其他bean类型（在配置文件中或者注解配置的bean）
复杂类型/集合类型
注入的方式有三种：
第一种：使用构造函数提供
第二种：使用set方法提供
第三种：使用注解提供（明天的内容）
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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--构造函数注入
使用的标签：constructure-arg
标签出现的位置：bean标签的内部
标签中的属性：
type：指定要注入数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值。参数索引的位置从0开始
name：用于指定给构造函数中指定名称的参数赋值※常用的是名称
===================以上三个用于指定给构造函数中的哪个参数赋值=====================
value：用于提供基本类型和String类型的数据
ref：引用关联的bean对象，指定其他的bean类型数据，指的是在Spring的IOC容器中出现过的bean对象
优势：在获取bean对象时，注入数据是必须操作，否则对象无法创建成功【不需要getset方法】
弊端：改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供
-->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
<constructor-arg name="name" value="字符串"></constructor-arg>
<constructor-arg name="age" value="18"></constructor-arg>
<constructor-arg name="birthday" ref="now"></constructor-arg>
</bean>
<!--配置一个日期对象-->
<bean id="now" class="java.util.Date"></bean>
</beans>package com.itheima.service.impl;
import com.itheima.service.IAccountService;
import java.util.Date;
/**
* 账户的业务层实现类
*/
public class AccountServiceImpl implements IAccountService {
//如果是经常变化的数据，并不适用于注入的方式
private String name;
private Integer age;
private Date birthday;//Bean类型
public AccountServiceImpl(String name, Integer age, Date birthday) {
this.name = name;
this.age = age;
this.birthday = birthday;
}
public AccountServiceImpl() {
}
//private IAccountDao accountDao = null;
public void saveAccount() {
System.out.println("service中的saveAccount方法执行了..."+name+","+age+","+birthday);
}
}3、set方法注入
<?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="now" class="java.util.Date"></bean>
<!--set方法注入※更常用
涉及的标签：property
出现的位置：bean标签的内部
标签的属性：
name：指定注入时所调用的set方法名称，关心set方法去掉set和大写
===================以上三个用于指定给构造函数中的哪个参数赋值=====================
value：用于提供基本类型和String类型的数据
ref：引用关联的bean对象，指定其他的bean类型数据，指的是在Spring的IOC容器中出现过的bean对象
优势：
创建对象时没有明确的限制，可以直接使用默认构造函数
弊端：
如果有某个成员必须有值，则获取对象时，有可能set方法没有执行
即调用了AccountServiceImpl2构造，对象用完，set无法执行
-->
<bean id="accountService2" class="com.itheima.service.impl.AccountServiceImpl2">
<property name="username" value="test"></property>
<property name="age" value="21"></property>
<property name="birthday" ref="now"></property>
</bean>
</beans>4、注入集合数据
<?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中的依赖注入
依赖注入：Dependency Injection
IOC的作用：
降低/削减程序间的耦合程度（依赖关系）
依赖关系的管理
以后都交给了Spring维护
在当前类中需要用到其他类的对象，由Spring为我们提供，我们只需要在配置文件中说明
依赖关系的维护就称之为“依赖注入”
依赖注入：
能注入的数据由三类：
基本类型和String
其他bean类型（在配置文件中或者注解配置的bean）
复杂类型/集合类型
注入的方式有三种：
第一种：使用构造函数提供
第二种：使用set方法提供
第三种：使用注解提供（明天的内容）
-->
<!--构造函数注入
使用的标签：constructure-arg
标签出现的位置：bean标签的内部
标签中的属性：
type：指定要注入数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值。参数索引的位置从0开始
name：用于指定给构造函数中指定名称的参数赋值※常用的是名称
===================以上三个用于指定给构造函数中的哪个参数赋值=====================
value：用于提供基本类型和String类型的数据
ref：引用关联的bean对象，指定其他的bean类型数据，指的是在Spring的IOC容器中出现过的bean对象
优势：在获取bean对象时，注入数据是必须操作，否则对象无法创建成功【不需要getset方法】
弊端：改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供
-->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
<constructor-arg name="name" value="字符串"></constructor-arg>
<constructor-arg name="age" value="18"></constructor-arg>
<constructor-arg name="birthday" ref="now"></constructor-arg>
</bean>
<!--配置一个日期对象-->
<bean id="now" class="java.util.Date"></bean>
<!--set方法注入※更常用
涉及的标签：property
出现的位置：bean标签的内部
标签的属性：
name：指定注入时所调用的set方法名称，关心set方法去掉set和大写
===================以上三个用于指定给构造函数中的哪个参数赋值=====================
value：用于提供基本类型和String类型的数据
ref：引用关联的bean对象，指定其他的bean类型数据，指的是在Spring的IOC容器中出现过的bean对象
优势：
创建对象时没有明确的限制，可以直接使用默认构造函数
弊端：
如果有某个成员必须有值，则获取对象时，有可能set方法没有执行
即调用了AccountServiceImpl2构造，对象用完，set无法执行
-->
<bean id="accountService2" class="com.itheima.service.impl.AccountServiceImpl2">
<property name="username" value="test"></property>
<property name="age" value="21"></property>
<property name="birthday" ref="now"></property>
</bean>
<!--复杂类型（集合类型）的注入（两大类）
用于给list结构集合注入的标签：list array set
用于给map结构集合注入的标签：map prop
结构相同，标签可以互换
-->
<bean id="accountService3" class="com.itheima.service.impl.AccountServiceImpl3">
<property name="myStrs">
<array>
<value>aaa</value>
<value>bbb</value>
<value>ccc</value>
</array>
</property>
<property name="myList">
<list>
<value>aaa</value>
<value>bbb</value>
<value>ccc</value>
</list>
</property>
<property name="mySet">
<list>
<value>aaa</value>
<value>bbb</value>
<value>ccc</value>
</list>
</property>
<property name="myMap">
<map>
<entry key="testA" value="aaa"></entry>
<entry key="testB">
<value>BBB</value>
</entry>
</map>
</property>
<property name="myProp">
<props>
<prop key="testc">cccc</prop>
<prop key="testd">ddd</prop>
</props>
</property>
</bean>
</beans>package com.itheima.service.impl;
import com.itheima.service.IAccountService;
import java.util.*;
/**
* 账户的业务层实现类
*/
public class AccountServiceImpl3 implements IAccountService {
//如果是经常变化的数据，并不适用于注入的方式
private String[] myStrs;
private List<String> myList;
private Set<String> mySet;
private Map<String,String> myMap;
private Properties myProp;
public void setMyStrs(String[] myStrs) {
this.myStrs = myStrs;
}
public void setMyList(List<String> myList) {
this.myList = myList;
}
public void setMySet(Set<String> mySet) {
this.mySet = mySet;
}
public void setMyMap(Map<String, String> myMap) {
this.myMap = myMap;
}
public void setMyProp(Properties myProp) {
this.myProp = myProp;
}
public void saveAccount() {
System.out.println(Arrays.toString(myStrs));
System.out.println(myList);
System.out.println(mySet);
System.out.println(myMap);
System.out.println(myProp);
}
}package com.itheima.ui;
import com.itheima.service.IAccountService;
import com.itheima.service.impl.AccountServiceImpl;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
/**
*
*/
public class Client {
/**
* 获取Spring的IOC核心容器，并根据id获取对象
* @param args
*/
public static void main(String[] args) {
//1.获取核心容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//2.根据id获取bean对象---两种方式
/*IAccountService as = (IAccountService) ac.getBean("accountService");
as.saveAccount();*/
//没有调用销毁时，容器已经消失了
//可以手动关闭容器
IAccountService as = (IAccountService) ac.getBean("accountService3");
as.saveAccount();
}
}五、今日课程总结IOC
- 关注代码的健壮性
- Spring的IOC能解决什么问题
- 如何搭建Spring中基于xml的IOC环境
- 如何通过依赖注入降低类之间的依赖关系
- 明日：注解、注解IOC到底做了什么事
本文来自博客园，作者：哥们要飞，转载请注明原文链接：https://www.cnblogs.com/liujinhui/p/d26b507c6f9336515f985d957c4d841a.html
浙公网安备 33010602011771号