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到底做了什么事
Spring01:概述、工厂模式解耦、Spring中的IOC的更多相关文章
- Java工厂模式解耦 —— 理解Spring IOC
Java工厂模式解耦 -- 理解Spring IOC 最近看到一个很好的思想来理解Spring IOC,故记录下来. 资源获取方式 主动式:(要什么资源都自己创建) 被动式:(资源的获取不是我们创建, ...
- 工厂模式模拟Spring的bean加载过程
一.前言 在日常的开发过程,经常使用或碰到的设计模式有代理.工厂.单例.反射模式等等.下面就对工厂模式模拟spring的bean加载过程进行解析,如果对工厂模式不熟悉的,具体可以先去学习一下工厂 ...
- 使用工厂模式解耦和IoC思想
使用工厂模式解耦. 一.需求场景: 某一层功能需要改动,但其他层代码不变 实现类1:MyDaoImpl查询自己的数据库. ====改为====> 实现类2:MyDaoImpl2从其它地址得到数据 ...
- 阶段3 2.Spring_02.程序间耦合_6 工厂模式解耦
使用类加载器去加载文件 定义getBean的方法 运行测试方法报错. 在工厂类里面打印输出BeanPath 删除dao的实现类 没有dao的实现类.再次运行程序.编译不报错.运行时报错 以上就是工厂模 ...
- 用IDEA详解Spring中的IoC和DI(挺透彻的，点进来看看吧)
用IDEA详解Spring中的IoC和DI 一.Spring IoC的基本概念 控制反转(IoC)是一个比较抽象的概念,它主要用来消减计算机程序的耦合问题,是Spring框架的核心.依赖注入(DI)是 ...
- 理解Spring中的IoC和DI
什么是IoC和DI IoC(Inversion of Control 控制反转):是一种面向对象编程中的一种设计原则,用来减低计算机代码之间的耦合度.其基本思想是:借助于"第三方" ...
- Spring中的IOC
在学习spring的时候,最常听到的词应该就是IOC和AOP了,以下,我从我的角度再次理解一下Spring里的IOC和AOP. IOC简单介绍 IoC(InversionofControl):IoC就 ...
- Spring中的IOC示例
Spring中的IOC示例 工程的大概内容是: 一个人在中国时用中国话问候大家,在国外时用英语问候大家. 其中, IHelloMessage是接口,用来定义输出问候信息 public interfac ...
- 详谈 Spring 中的 IOC 和 AOP
这篇文章主要讲 Spring 中的几个点,Spring 中的 IOC,AOP,下一篇说说 Spring 中的事务操作,注解和 XML 配置. Spring 简介 Spring 是一个开源的轻量级的企业 ...
- 002-创建型-04-建造者模式（Builder）、JDK1.7源码中的建造者模式、Spring中的建造者模式
一.概述 建造者模式的定义:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示. 工厂类模式提供的是创建单个类的模式,而建造者模式则是将各种产品集中起来进行管理,用来创建复合对象 ...
随机推荐
- 如何修改 Kubernetes 节点 IP 地址
转载自:https://www.qikqiak.com/post/how-to-change-k8s-node-ip/ 昨天网络环境出了点问题,本地的虚拟机搭建的 Kubernetes 环境没有固定 ...
- 13. 第十二篇 二进制安装kubelet
文章转载自:https://mp.weixin.qq.com/s?__biz=MzI1MDgwNzQ1MQ==&mid=2247483842&idx=1&sn=1ef1cb06 ...
- rocketmq 4.x 双主双从同步读写
文章标题写的是多M多S同步双写集群安装,但是看具体参数配置,写的是异步复制Master brokerRole=ASYNC_MASTER flushDiskType=SYNC_FLUSH #刷盘方式 # ...
- IDEA设置问题
一. IDEA 相关设置 1.1 去除SQL语句的黄色背景 Settings > Editor > Inspections > SQL No data sources configu ...
- 对list集合中元素按照某个属性进行排序
test 为集合中的元素类型(其中包含i属性) Collections.sort(list,(test o1, test o2) -> { if (o1.getI() != o2.getI()) ...
- 无需Steam的Proton，在你的Linux运行任意Windows游戏！
链接: https://pan.baidu.com/s/1QeJxj9_2aZPk2_uZMzpn9A 提取码: v6t6 包含的版本 Proton4.11 Proton4.2 Proton5.0 ...
- 关于Redhat-7.x-下docker的安装记录
今天因公司项目,需要部署docker环境,能根据指定的镜像创建容器 于是首先就得先部署docker环境,过程记录如下: 在Redhat 7.x - (aws上的Redhat) 环境下部署过程 1.安装 ...
- DDD-领域驱动（二）-贫血模型与充血模型
贫血模型 一般来说 贫血模型:**一个类中只有属性或者成员变量,没有方法 **!例如 DbFirst 从数据库同步实体过来, -- 对于一个系统刚开始的时候会觉得这时候是最舒服的,但是如果后期系统需要 ...
- vue实现功能 单选 取消单选 全选 取消全选
vue实现功能 单选 取消单选 全选 取消全选 代码部分 <template> <div class=""> <h1>全选框</h1> ...
- Docker | 发布镜像到镜像仓库
本文记录发布镜像到 DockerHub 和 阿里云镜像仓库.工作中使用的是JFrog Artifactory 和 Harbor,没有太大差别. 发布镜像到DockerHub https://hub.d ...