Spring入门系列-IOC
作者：互联网
什么是Spring
Spring概述(了解)
Spring是什么
Spring是JavaEE应用 full-stack轻量级开源框架，核心是：IoC（Inverse Of Control：反转控制）和AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层Spring MVC和持久层Spring JDBC以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE企业应用开源框架。
什么是一站式开发：
Spring的历史
1997年IBM提出了EJB的思想
1998年，SUN制定开发标准规范EJB1.0
1999年，EJB1.1发布
2001年，EJB2.0发布
2003年，EJB2.1发布
2006年，EJB3.0发布
Rod Johnson（spring之父）
Expert One-to-One J2EE Design and Development(2002)
阐述了J2EE使用EJB开发设计的优点及解决方案
Expert One-to-One J2EE Development without EJB(2004)
阐述了J2EE开发不使用EJB的解决方式（Spring雏形）
2017年9月份发布了spring的最新版本spring 5.0通用版（GA）
为什么使用Spring
- 方便解耦，简化开发
通过Spring提供的IoC容器，可以将对象间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。 - AOP编程的支持 （jdk动态代理）
通过Spring的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。
声明式事务的支持可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理，提高开发效率和质量。 - 方便程序的测试（和Junit整合）
可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。 - 方便集成各种优秀框架
Spring可以降低各种框架的使用难度，提供了对各种优秀框架（Struts、Hibernate、Hessian、Quartz等）的直接支持。 - 降低JavaEE API的使用难度 （SSM整合）
Spring对JavaEE API（如JDBC、JavaMail、远程调用等）进行了薄薄的封装层，使这些API的使用难度大为降低。
Java源码是经典学习范例
Spring的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。它的源代码无意是Java技术的最佳实践的范例。Spring的体系结构
IOC引入
程序的耦合和解耦(理解)
什么是程序的耦合
耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差( 降低耦合性，可以提高其独立性)。
耦合性存在于各个领域，而非软件设计中独有的，但是我们只讨论软件工程中的耦合。
在软件工程中，耦合指的就是就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个准则就是高内聚低耦合。
它有如下分类：（了解）
（1） 内容耦合。当一个模块直接修改或操作另一个模块的数据时，或一个模块不通过正常入口而转入另一个模块时，这样的耦合被称为内容耦合。内容耦合是最高程度的耦合，应该避免使用之。
（2） 公共耦合。两个或两个以上的模块共同引用一个全局数据项，这种耦合被称为公共耦合。在具有大量公共耦合的结构中，确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。
（3） 外部耦合 。一组模块都访问同一全局简单变量而不是同一全局数据结构，而且不是通过参数表传递该全局变量的信息，则称之为外部耦合。
（4） 控制耦合 。一个模块通过接口向另一个模块传递一个控制信号，接受信号的模块根据信号值而进行适当的动作，这种耦合被称为控制耦合。
（5） 标记耦合 。若一个模块A通过接口向两个模块B和C传递一个公共参数，那么称模块B和C之间存在一个标记耦合。
（6） 数据耦合。模块之间通过参数来传递数据，那么被称为数据耦合。数据耦合是最低的一种耦合形式，系统中一般都存在这种类型的耦合，因为为了完成一些有意义的功能，往往需要将某些模块的输出数据作为另一些模块的输入数据。
（7） 非直接耦合 。两个模块之间没有直接关系，它们之间的联系完全是通过主模块的控制和调用来实现的。
总结：
耦合是影响软件复杂程度和设计质量的一个重要因素，在设计上我们应采用以下原则：如果模块间必须存在耦合，就尽量使用数据耦合，少用控制耦合，限制公共耦合的范围，尽量避免使用内容耦合。
内聚与耦合
内聚标志一个模块内各个元素彼此结合的紧密程度，它是信息隐蔽和局部化概念的自然扩展。内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事。它描述的是模块内的功能联系。耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据。 程序讲究的是低耦合，高内聚。就是同一个模块内的各个元素之间要高度紧密，但是各个模块之间的相互依存度却要不那么紧密。
内聚和耦合是密切相关的，同其他模块存在高耦合的模块意味着低内聚，而高内聚的模块意味着该模块同其他模块之间是低耦合。在进行软件设计时，应力争做到高内聚，低耦合。我们在开发中，有些依赖关系是必须的，有些依赖关系可以通过优化代码来解除的。
请看下面的示例代码：
/**
* 账户的业务层实现类
*/
public class AccountServiceImpl implements IAccountService {
private AccountDao accountDao = new AccountDaoImpl();
} 上面的代码表示：
业务层调用持久层，并且此时业务层在依赖持久层的接口和实现类。如果此时没有持久层实现类，编译将不能通过。这种编译期依赖关系，应该在我们开发中杜绝。我们需要优化代码解决。
再比如：
早期我们的JDBC操作，注册驱动时，我们为什么不使用DriverManager的register方法，而是采用Class.forName的方式？
public class JdbcDemo1 {
/**
*/
public static void main(String[] args) throws Exception {
//1.注册驱动
//DriverManager.registerDriver(new com.mysql.jdbc.Driver());
Class.forName("com.mysql.jdbc.Driver");
//2.获取连接
//3.获取预处理sql语句对象
//4.获取结果集
//5.遍历结果集
}
}
原因就是：
我们的类依赖了数据库的具体驱动类（MySQL），如果这时候更换了数据库品牌（比如Oracle），需要修改源码来重新数据库驱动。这显然不是我们想要的。
案例一：使用反射技术创建JDBC连接
第一步：创建工程
groupId: com.jack
artifactId: spring_day01_jdbc
第二步：导入maven坐标，pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.jack</groupId>
<artifactId>spring_day01_jdbc</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.38</version>
</dependency>
</dependencies>
</project>第三步：创建数据库和表
创建数据库ssm
创建表 account
create table account(
id int primary key auto_increment,
name varchar(40),
money float
)character set utf8 collate utf8_general_ci;
insert into account(name,money) values('aaa',1000);
insert into account(name,money) values('bbb',1000);
insert into account(name,money) values('ccc',1000);第四步：创建JdbcDemo.java，测试连接数据库
package com.jack.demo;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
/**
* @author fztomaster
*/
public class JdbcDemo {
public static void main(String[] args) throws Exception{
//1.注册驱动
// DriverManager.registerDriver(new com.mysql.jdbc.Driver());
Class.forName("com.mysql.jdbc.Driver"); // 解决了程序之间的耦合
//2.获取连接
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/ssm","root","root");
//3.获取操作数据库的预处理对象
PreparedStatement pstm = conn.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();
conn.close();
}
}案例二：使用工厂模式+反射技术创建对象
第一步: 创建工程
groupId: com.jack
artifactId: spring_day01_factory
第二步：创建包com.jack.dao，创建接口AccountDao.java
package com.jack.dao;
/**
* @author fztomaster
* 账户的持久层接口
*/
public interface AccountDao {
/**
* 模拟保存账户
*/
public void saveAccount();
}创建包com.jack.dao.impl，创建类AccountDaoImpl.java实现接口AccountDao.java
package com.jack.dao.impl;
import com.jack.dao.AccountDao;
/**
* @author fztomaster
* 账户的持久层实现类
*/
public class AccountDaoImpl implements AccountDao {
/**
* 模拟保存账户
*/
public void saveAccount() {
System.out.println("执行AccountDao中的saveAccount()方法");
}
}第三步：创建com.jack.service，创建接口AccountService.java
package com.jack.service;
/**
* @author fztomaster
* 账户的业务层接口
*/
public interface AccountService {
/**
* 模拟保存账户
*/
public void saveAccount();
}创建包com.jack.service.impl，创建接口的实现类AccountServiceImpl.java
package com.jack.service.impl;
import com.jack.dao.AccountDao;
import com.jack.factory.BeanFactory;
import com.jack.service.AccountService;
/**
* @author fztomaster
* 账户的业务层实现类
*/
public class AccountServiceImpl implements AccountService {
// 耦合
// AccountDao accountDao = new AccountDaoImpl();
int i = 1;
/**
* 模拟保存账户
*/
public void saveAccount() {
// 单例对象，尽量不要设置成全局变量，因为对属性的赋值会影响全局变量(不会影响局部变量)
// 多例对象，对属性的赋值不会改变全局变量
System.out.println(i);
AccountDao accountDao = (AccountDao) BeanFactory.getBean("accountDao");
System.out.println("执行AccountService中的saveAccount()方法");
accountDao.saveAccount();
i++;
}
}第四步：创建com.jack.ui，创建类Client.java，表现层
package com.jack.ui;
import com.jack.factory.BeanFactory;
import com.jack.service.AccountService;
/**
* @author fztomaster
* 账户的表现层，用于调用业务层
*/
public class Client {
// 模拟Action
public static void main(String[] args) {
// 耦合
// AccountService accountService = new AccountServiceImpl();
// 解耦(使用BeanFactory)
for (int i = 0; i < 5; i++) {
AccountService accountService = (AccountService) BeanFactory.getBean("accountService");
accountService.saveAccount();
System.out.println(accountService); // 对象是否是同一个对象
}
}
}第五步：在resources目录下，创建bean.properites
accountDao=com.jack.dao.impl.AccountDaoImpl
accountService=com.jack.service.impl.AccountServiceImpl第六步：创建 工厂类，用来创建对象
创建包com.jack.factory，创建类BeanFactory.java
package com.jack.factory;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
/**
* @author fztomaster
* 工厂模式：
* 1. 创建一个工厂，由工厂负责创建对象
* 2. 将创建对象封装到XML文件中，或者properties文件中
* 3. 由工厂创建的对象时单例的还是多例的呢
*
* 一个创建Bean对象的工厂
*
* Bean：在计算机英语中，有可重用组件的含义。
* JavaBean：用java语言编写的可重用组件。
* javabean --> 实体类
*
* 它就是创建我们的service和dao对象的。
*
* 第一个：需要一个配置文件来配置我们的service和dao
* 配置的内容：唯一标识=全限定类名（key=value)
* 第二个：通过读取配置文件中配置的内容，反射创建对象
*
* 我的配置文件可以是xml也可以是properties
*/
public class BeanFactory {
// 使用Properties解析properties文件
private static Properties prop;
// 使用Map<String, Object>集合，存放对象的key和创建的对象
private static Map<String, Object> bean;
// 通过静态代码块(运行BeanFactory，一定会被加载，只被加载一次)
static {
// 读取bean.properties文件
prop = new Properties();
// Map集合
bean = new HashMap<String, Object>();
// 读取每个key的值
InputStream in =BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
try {
prop.load(in);
Enumeration<Object> keys = prop.keys();
while (keys.hasMoreElements()) {
// 获取properties文件中的key
String key = (String) keys.nextElement();
// 通过key，获取key所对应的对象的路径
String objectPath = prop.getProperty(key);
// 使用路径，通过反射技术，获取对象
Object object = Class.forName(objectPath).newInstance();
// 将key和Object对象存放到map集合中
bean.put(key, object);
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 通过key的名称，获取对象(单例)
* @param key
* @return
*/
/*public static Object getBean(String key) {
return bean.get(key);
}*/
/**
* 通过key的名称，获取对象(多例)
* @param key
* @return
*/
public static Object getBean(String key) {
String objectPath = prop.getProperty(key);
Object object = null;
try {
object = Class.forName(objectPath).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return object;
}
}解决程序耦合的思路
jdbc在操作时，是通过反射来注册驱动的，代码如下：
Class.forName("com.mysql.jdbc.Driver");//此处只是一个字符串 此时的好处是，我们的类中不再依赖具体的驱动类，此时就算删除mysql的驱动jar包，依然可以编译（运行就不要想了，没有驱动不可能运行成功的）。
同时，也产生了一个新的问题，mysql驱动的全限定类名字符串是在java类中写死的，一旦要改还是要修改源码。
解决这个问题也很简单，使用配置文件配置（xml或者是properties）。
工厂模式解耦
在实际开发中我们可以把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的方法通过读取配置文件，把这些对象创建出来并存起来。在接下来的使用的时候，直接拿过来用就好了。
那么，这个读取配置文件，创建和获取三层对象的类就是工厂。
控制反转-Inversion Of Control
解耦的思路有2个问题：
1、存哪去？
分析：由于我们是很多对象，肯定要找个集合来存。这时候有Map和List供选择。
到底选Map还是List就看我们有没有查找需求。因为有查找需求，选Map。
所以我们的答案就是在应用加载时，创建一个Map，用于存放三层对象。
我们把这个map称之为容器。
2、还是没解释什么是工厂？
工厂就是负责给我们从容器中获取指定对象的类。这时候我们获取对象的方式发生了改变。而不是我们在程序中去new对象，而是通过工厂去创建对象，并且通过工厂去获取对象。
原来：
我们在获取对象时，都是采用new的方式。是主动的
现在：
我们获取对象时，同时跟工厂要，有工厂为我们查找或创建对象，是被动的。
这种被动接收的方式获取对象的思想就是控制反转，它是spring框架的核心之一。
明确ioc的作用： 削减计算机程序的耦合(解除我们代码中的依赖关系)，将对象的创建和调用都交给spring容器去处理。
IOC使用
官网：http://spring.io/
下载地址：
http://repo.springsource.org/libs-release-local/org/springframework/spring 解压:(Spring目录结构:)
- docs: API和开发规范.
- libs: jar包和源码.
- schema: 约束.
IOC入门
创建工程
导入spring的依赖包
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.jack</groupId>
<artifactId>spring_day01_ioc</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.7.RELEASE</version>
</dependency>
</dependencies>
</project>
创建包com.jack.dao，创建接口AccountDao.java
package com.jack.dao;
/**
* @author fztomaster
* 账户的持久层接口
*/
public interface AccountDao {
/**
* 保存账户
*/
public void saveAccount();
}创建包com.jack.dao.impl，创建实现类AccountDaoImpl.java
package com.jack.dao.impl;
import com.jack.dao.AccountDao;
/**
* @author fztomaster
* 账户的持久层实现类
*/
public class AccountDaoImpl implements AccountDao {
/**
* 保存账户
*/
public void saveAccount() {
System.out.println("AccountDao中的saveAccount()方法...");
}
}
创建包com.jack.service，创建接口AccountService.java
package com.jack.service;
/**
* @author fztomaster
* 账户的业务层接口
*/
public interface AccountService {
/**
* 保存账户
*/
public void saveAccount();
}创建包com.jack.service.impl，创建接口实现类AccountServiceImpl.java
package com.jack.service.impl;
import com.jack.dao.AccountDao;
import com.jack.service.AccountService;
/**
* @author fztomaster
* 账户的业务层实现类
*/
public class AccountServiceImpl implements AccountService {
private AccountDao accountDao;
/**
* 保存账户
*/
public void saveAccount() {
System.out.println("AccountService中的saveAccount()方法...");
accountDao.saveAccount();
}
}在resources目录下，创建applicationContext.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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--
IOC: 将对象的创建权交给spring容器管理
id: 对象创建的key(表示唯一)
class: 创建对象的全路径(底层用到反射)
-->
<bean id="accountService" class="com.jack.service.impl.AccountServiceImpl"></bean>
<bean id="accountDao" class="com.jack.dao.impl.AccountDaoImpl"></bean>
</beans>ApplicationContext接口对象
参考：ApplicationContext和ClassPathXmlApplicationContext、FileSystemXmlApplicationContex的关系。
BeanFactory和ApplicationContext的区别
BeanFactory 才是Spring 容器中的顶层接口。
ApplicationContext 是它的子接口。
BeanFactory 和ApplicationContext 的区别：
创建对象的时间点不一样。
ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。（立即加载）
BeanFactory：什么时候使，用什么时候创建对象。（延迟加载）ApplicationContext 接口的实现类
（1）ClassPathXmlApplicationContext：
它是从类的根路径下加载配置文件 推荐使用这种
（2）FileSystemXmlApplicationContext：
它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
（3）AnnotationConfigApplicationContext:
当我们使用注解配置容器对象时，需要使用此类来创建spring 容器。它用来读取注解。 测试类
创建包com.jack.ui，创建测试类Client.java
package com.jack.ui;
import com.jack.service.AccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* @author fztomaster
*/
public class Client {
/**
* 模拟action
* @param args
*/
public static void main(String[] args) {
test();
}
/**
* 测试由ApplicationContext对象获取spring容器中创建的对象
*/
public static void test() {
// 代码之间存在依赖关系(耦合)
// AccountService accountService = new AccountServiceImpl();
// 由spring创建对象(完成对象的解耦)
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
// 通过名称调用(通过spring容器中的id属性)-推荐使用
AccountService accountService = (AccountService) ac.getBean("accountService");
// 通过类型调用(通过spring容器中的class属性)
// AccountServiceImpl accountService = ac.getBean(AccountServiceImpl.class);
accountService.saveAccount();
}
}id和name的配置
id中不能出现特殊字符，name中可以出现特殊的字符。
可以指定多个name，之间可以用分号（“；”）、空格（“ ”）或逗号（“，”）分隔开，如果没有指定id，那么第一个name为标识符，其余的为别名； 若指定了id属性，则id为标识符，所有的name均为别名。如：
<bean name="alias1 alias2;alias3,alias4" id="hello1" class="com.zyh.spring3.hello.HelloWorld"> </bean> 此时，hello1为标识符，而alias1，alias2，alias3，alias4为别名，它们都可以作为Bean的键值；
实例化bean的3种方式
创建工程
groupId: com.jack
artifactId: spring_day01_bean
导入坐标，pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.jack</groupId>
<artifactId>spring_day01_bean</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
</dependencies>
</project>创建service层接口和实现类
AccountService.java
package com.jack.service;
/**
* @author fztomaster
* 账户业务层接口
*/
public interface AccountService {
/**
* 保存账户
*/
void saveAccount();
}AccountServiceImpl.java
package com.jack.service.impl;
import com.jack.service.AccountService;
/**
* @author fztomaster
* 账户业务层实现类
*/
public class AccountServiceImpl implements AccountService {
public AccountServiceImpl() {
System.out.println("AccountServiceImpl初始化了...");
}
public void saveAccount() {
System.out.println("保存账户...");
}
public void init() {
System.out.println("对象初始化了...");
}
public void destory() {
System.out.println("对象销毁了...");
}
}测试类
TestIOC.java
package com.jack.test;
import com.jack.service.AccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* @author fztomaster
*/
public class TestIOC {
public static void main(String[] args) {
// instanceBean();
// testScope();
testInitAndDestory();
}
private static void instanceBean() {
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
AccountService accountService = ac.getBean("accountService", AccountService.class);
System.out.println(accountService);
AccountService accountService2 = ac.getBean("accountService2", AccountService.class);
System.out.println(accountService2);
AccountService accountService3 = ac.getBean("accountService3", AccountService.class);
System.out.println(accountService3);
}
private static void testScope() {
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
AccountService accountService = ac.getBean("accountService", AccountService.class);
AccountService accountService2 = (AccountService) ac.getBean("accountService");
System.out.println(accountService == accountService2);
}
private static void testInitAndDestory() {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
AccountService accountService = ac.getBean("accountService", AccountService.class);
accountService.saveAccount();
// 手动关闭
ac.close();
}
}配置文件applicationContext.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="accountService" class="com.jack.service.impl.AccountServiceImpl" scope="singleton" init-method="init" destroy-method="destory"></bean>
<!--第二种：静态工厂方式实例化bean-->
<!--<bean id="accountService2" class="com.jack.factory.StaticFactory" factory-method="getAccountService"></bean>-->
<!--第三种：实例工厂方式实例化bean-->
<!--<bean id="instanceFactory" class="com.jack.factory.InstanceFactory"></bean>-->
<!--<bean id="accountService3" factory-bean="instanceFactory" factory-method="getAccountServiceByInstanceFactory"></bean>-->
</beans>静态工厂和实例工厂
StaticFactory.java
package com.jack.factory;
import com.jack.service.AccountService;
import com.jack.service.impl.AccountServiceImpl;
/**
* @author fztomaster
* 静态工厂
*/
public class StaticFactory {
public static AccountService getAccountService() {
return new AccountServiceImpl();
}
}InstanceFactory.java
package com.jack.factory;
import com.jack.service.AccountService;
import com.jack.service.impl.AccountServiceImpl;
/**
* @author fztomaster
* 实例工厂
*/
public class InstanceFactory {
public AccountService getAccountServiceByInstanceFactory() {
return new AccountServiceImpl();
}
}总结
实例化bean有3种方式(xml方式)：
- 无参数的构造方法实例化bean-使用最多
- 静态工厂实例化bean
- 实例工厂实例化bean
Bean的作用访问配置：scope配置
Spring创建这个类的时候，默认采用的单例的模式进行创建的。如果想去改变单例模式，需要通过scope进行配置。
Scope属性中有以下几个取值:
- singleton ：默认值，单例的。
prototype ：多例的
request ：应用在web应用中，将创建的对象存入到request域中。
session ：应用在web应用中，将创建的对象存入到session域中。
globalsession ：应用在集群环境下使用。将创建的对象存入到全局的session中。
applicaitonContext.xml中的配置
<!-- bean的作用范围调整
bean标签的scope属性：
作用：用于指定bean的作用范围
取值： 常用的就是单例的和多例的
singleton：单例的（默认值）
prototype：多例的
request：作用于web应用的请求范围
session：作用于web应用的会话范围
global-session：作用于集群环境的会话范围（全局会话范围），当不是集群环境时，它就是session
-->
<bean id="accountService" class="com.jack.service.impl.AccountServiceImpl" scope="prototype"></bean>Bean的生命周期配置
单例对象
出生：当容器创建时对象出生
活着：只要容器还在，对象一直活着
死亡：容器销毁，对象消亡
总结：单例对象的生命周期和容器相同多例对象
出生：当我们使用对象时spring框架为我们创建
活着：对象只要是在使用过程中就一直活着。
死亡：当对象长时间不用，且没有别的对象引用时，由Java的垃圾回收器回收
总结：多例对象的声明周期和对象是否被使用有关。与容器是否被销毁无关。AccountServiceImpl.java
package com.jack.service.impl;
import com.jack.service.AccountService;
/**
* @author fztomaster
* 账户业务层实现类
*/
public class AccountServiceImpl implements AccountService {
public AccountServiceImpl() {
System.out.println("AccountServiceImpl初始化了...");
}
public void saveAccount() {
System.out.println("保存账户...");
}
public void init() {
System.out.println("对象初始化了...");
}
public void destory() {
System.out.println("对象销毁了...");
}
}applicationContext.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="accountService" class="com.jack.service.impl.AccountServiceImpl" scope="singleton" init-method="init" destroy-method="destory"></bean>
</beans>TestIOC.java
package com.jack.test;
import com.jack.service.AccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* @author fztomaster
*/
public class TestIOC {
public static void main(String[] args) {
testInitAndDestory();
}
private static void testInitAndDestory() {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
AccountService accountService = ac.getBean("accountService", AccountService.class);
accountService.saveAccount();
// 手动关闭
ac.close();
}
}依赖注入DI
依赖注入：Dependency Injection。它是spring框架核心ioc的具体实现。
我们的程序在编写时，通过控制反转，把对象的创建交给了spring，但是代码中不可能出现没有依赖的情况。ioc解耦只是降低他们的依赖关系，但不会消除。例如：我们的业务层仍会调用持久层的方法。
那这种业务层和持久层的依赖关系，在使用spring之后，就让spring来维护了。
简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。 这就是依赖注入。
依赖注入：
- 能注入的数据：有三类
- 基本类型和String
- 其他bean类型（在配置文件中或者注解配置过的bean）
- 复杂类型/集合类型
- 能注入的方式：有三种
- 使用构造方法提供
- 使用set方法提供（使用p名称空间注入）
- 使用注解提供
案例
创建工程
groupId: com.jack
artifactId: spring_day01_di
导入坐标，pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.jack</groupId>
<artifactId>spring_day01_di</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.8.1</version>
</dependency>
</dependencies>
</project>创建service层接口
AccountService.java
package com.jack.service;
/**
* @author fztomaster
* 账户的业务层接口
*/
public interface AccountService {
/**
* 保存账户
*/
void saveAccount();
}构造方法注入
构造函数注入：
使用的标签:constructor-arg
标签出现的位置：bean标签的内部
标签中的属性
type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置是从0开始
name：用于指定给构造函数中指定名称的参数赋值 常用的
=============以上三个用于指定给构造函数中哪个参数赋值===============================
value：用于提供基本类型和String类型的数据
ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象
优势：
在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功。
弊端：
改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供。AccountServiceConstructorImpl.java
package com.jack.service.impl;
import com.jack.service.AccountService;
import java.util.Date;
/**
* @author fztomaster
* 构造方法注入
*/
public class AccountServiceConstructorImpl implements AccountService {
private String name;
private int age;
private Date birthday;
public AccountServiceConstructorImpl() {
}
public AccountServiceConstructorImpl(String name, int age, Date birthday) {
this.name = name;
this.age = age;
this.birthday = birthday;
}
/**
* 保存账户
*/
public void saveAccount() {
System.out.println("保存账户...");
}
}applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:p="http://www.springframework.org/schema/p"
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="accountService" class="com.jack.service.impl.AccountServiceConstructorImpl">
<constructor-arg name="name" value="jack"></constructor-arg>
<constructor-arg name="age" value="18"></constructor-arg>
<constructor-arg name="birthday" ref="date"></constructor-arg>
</bean>
<bean id="date" class="java.util.Date"></bean>
</beans>set方法注入
set方法注入-更常用的方式
涉及的标签：property
出现的位置：bean标签的内部
标签的属性
name：用于指定注入时所调用的set方法名称
value：用于提供基本类型和String类型的数据
ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象
优势：
创建对象时没有明确的限制，可以直接使用默认构造函数
弊端：
如果有某个成员必须有值，则获取对象是有可能set方法没有执行。
AccountServiceSetImpl.java
package com.jack.service.impl;
import com.jack.service.AccountService;
import java.util.Date;
/**
* @author fztomaster
* set方式注入
*/
public class AccountServiceSetImpl implements AccountService {
private String name;
private int age;
private Date birthday;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
/**
* 保存账户
*/
public void saveAccount() {
System.out.println("保存账户...");
}
}applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:p="http://www.springframework.org/schema/p"
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="date" class="java.util.Date"></bean>
<!--
set方法注入
-->
<bean id="accountService2" class="com.jack.service.impl.AccountServiceSetImpl">
<property name="name" value="rose"></property>
<property name="age" value="18"></property>
<property name="birthday" ref="date"></property>
</bean>
</beans>p空间注入(前提：需要有set方法)
- 引入p空间约束
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:p="http://www.springframework.org/schema/p"
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">
</beans>- 使用p名称空间完成属性注入
语法：
普通属性 p:属性名=””
对象类型 p:属性名-ref=""<!--
p空间注入
-->
<bean id="accountService3" class="com.jack.service.impl.AccountServiceSetImpl" p:name="jerry" p:age="20" p:birthday-ref="date"></bean>
<bean id="date" class="java.util.Date"></bean>注意：需要对属性提供set方法，方可实现注入
注入集合属性
复杂类型的注入/集合类型的注入
用于给List结构集合注入的标签：
list array set
用于个Map结构集合注入的标签:
map props
结构相同，标签可以互换AccountServiceCollectionImpl.java
package com.jack.service.impl;
import com.jack.service.AccountService;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
/**
* @author fztomaster
* 注入集合
*/
public class AccountServiceCollectionImpl implements AccountService {
private String[] array;
private List<String> list;
private Set<String> set;
private Map<String, String> map;
private Properties props;
public String[] getArray() {
return array;
}
public void setArray(String[] array) {
this.array = array;
}
public List<String> getList() {
return list;
}
public void setList(List<String> list) {
this.list = list;
}
public Set<String> getSet() {
return set;
}
public void setSet(Set<String> set) {
this.set = set;
}
public Map<String, String> getMap() {
return map;
}
public void setMap(Map<String, String> map) {
this.map = map;
}
public Properties getProps() {
return props;
}
public void setProps(Properties props) {
this.props = props;
}
/**
* 保存账户
*/
public void saveAccount() {
System.out.println("保存账户...");
}
}applicationContext.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="accountService4" class="com.jack.service.impl.AccountServiceCollectionImpl">
<!--
array、set、list标签可以互换
map、props标签可以互换
-->
<property name="array">
<array>
<value>arr1</value>
<value>arr2</value>
<value>arr3</value>
</array>
</property>
<property name="list">
<list>
<value>list1</value>
<value>list2</value>
<value>list3</value>
</list>
</property>
<property name="set">
<set>
<value>set1</value>
<value>set2</value>
<value>set3</value>
</set>
</property>
<property name="map">
<map>
<entry key="k1" value="v1"></entry>
<entry key="k2" value="v2"></entry>
<entry key="k3" value="v3"></entry>
</map>
</property>
<!--properties第一种-->
<!--<property name="props">
<props>
<prop key="p1">v1</prop>
<prop key="p2">v2</prop>
<prop key="p3">v3</prop>
</props>
</property>-->
<!--properties第二种-->
<property name="props">
<value>
p1=v1
p2=v2
p3=v3
</value>
</property>
</bean>
</beans>测试类
TestDI.java
package com.jack.test;
import com.jack.service.AccountService;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* @author fztomaster
*/
public class TestDI {
public static void main(String[] args) {
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
AccountService accountService = ac.getBean("accountService", AccountService.class);
System.out.println("----------构造器注入----------");
System.out.println(ToStringBuilder.reflectionToString(accountService, ToStringStyle.JSON_STYLE));
System.out.println("----------set方式注入----------");
AccountService accountService2 = ac.getBean("accountService2", AccountService.class);
System.out.println(ToStringBuilder.reflectionToString(accountService2, ToStringStyle.JSON_STYLE));
System.out.println("----------p空间注入----------");
AccountService accountService3 = ac.getBean("accountService3", AccountService.class);
System.out.println(ToStringBuilder.reflectionToString(accountService3, ToStringStyle.JSON_STYLE));
System.out.println("----------集合属性注入----------");
AccountService accountService4 = ac.getBean("accountService4", AccountService.class);
System.out.println(ToStringBuilder.reflectionToString(accountService4, ToStringStyle.JSON_STYLE));
}
}标签：java,入门,AccountService,Spring,jack,import,com,public,IOC 来源： https://www.cnblogs.com/fztomaster/p/11479272.html