目录
- Spring简介
- Spring体系结构
- SpringIOC
- 控制反转思想
- 自定义对象容器
- Spring实现IOC
- Spring容器类型
- 容器接口
- 容器实现类
- 对象的创建方式
- 使用构造方法
- 使用工厂类的方法
- 使用工厂类的静态方法
- 对象的创建策略
- 对象的销毁时机
- 生命周期方法
- 获取Bean对象的方式
- 通过id/name获取
- 通过类型获取
- 通过类型+id/name获取
Spring简介
Spring是一个开源框架，为简化企业级开发而生。它以IOC（控制反转）和AOP（面向切面）为思想内核，提供了控制层SpringMVC、数据层SpringData、服务层事务管理等众多技术，并可以整合众多第三方框架。
Spring将很多复杂的代码变得优雅简洁，有效的降低代码的耦合度，极大的方便项目的后期维护、升级和扩展。
Spring官网地址：https://spring.io/
Spring体系结构
Spring框架根据不同的功能被划分成了多个模块，这些模块可以满足一切企业级应用开发的需求，在开发过程中可以根据需求有选择性地使用所需要的模块。
- Core Container：Spring核心模块，任何功能的使用都离不开该模块，是其他模块建立的基础。
- Data Access/Integration：该模块提供了数据持久化的相应功能。
- Web：该模块提供了web开发的相应功能。
- AOP：提供了面向切面编程实现
- Aspects：提供与AspectJ框架的集成，该框架是一个面向切面编程框架。
- Instrumentation：提供了类工具的支持和类加载器的实现，可以在特定的应用服务器中使用。
- Messaging：为Spring框架集成一些基础的报文传送应用
- Test：提供与测试框架的集成
SpringIOC
控制反转思想
IOC(Inversion of Control) ：程序将创建对象的权利交给框架。
之前在开发过程中，对象实例的创建是由调用者管理的，代码如下：
public interface StudentDao {
// 根据id查询学生
Student findById(int id);
}
public class StudentDaoImpl implements StudentDao{
@Override
public Student findById(int id) {
// 模拟从数据库查找出学生
return new Student(1,"张三","北京");
}
}
public class StudentService {
public Student findStudentById(int id){
// 此处就是调用者在创建对象
StudentDao studentDao = new StudentDaoImpl();
return studentDao.findById(1);
}
}
这种写法有两个缺点：
- 浪费资源：StudentService调用方法时即会创建一个对象，如果不断调用方法则会创建大量StudentDao对象。
- 代码耦合度高：假设随着开发，我们创建了StudentDao另一个更加完善的实现类StudentDaoImpl2，如果在StudentService中想使用StudentDaoImpl2，则必须修改源码。
而IOC思想是将==创建对象的权利交给框架==，框架会帮助我们创建对象，分配对象的使用，控制权由程序代码转移到了框架中，控制权发生了反转，这就是Spring的IOC思想。而IOC思想可以完美的解决以上两个问题。
自定义对象容器
接下来我们通过一段代码模拟IOC思想。创建一个集合容器，先将对象创建出来放到容器中，需要使用对象时，只需要从容器中获取对象即可，而不需要重新创建，此时容器就是对象的管理者。
创建实体类
public class Student { private int id; private String name; private String address; // 省略getter/setter/构造方法/tostring }创建Dao接口和实现类
public interface StudentDao { // 根据id查询学生 Student findById(int id); } public class StudentDaoImpl implements StudentDao{ @Override public Student findById(int id) { // 模拟从数据库查找出学生 return new Student(1,"张三","北京"); } } public class StudentDaoImpl2 implements StudentDao{ @Override public Student findById(int id) { // 模拟根据id查询学生 System.out.println("新方法！！！"); return new Student(1,"张三","北京"); } }创建配置文件bean.properties，该文件中定义管理的对象
studentDao=com.Spring.dao.StudentDaoImpl创建容器管理类，该类在类加载时读取配置文件，将配置文件中配置的对象全部创建并放入容器中。
public class Container { static Map<String,Object> map = new HashMap(); static { // 读取配置文件 InputStream is = Container.class.getClassLoader().getResourceAsStream("bean.properties"); Properties properties = new Properties(); try { properties.load(is); } catch (IOException e) { e.printStackTrace(); } // 遍历配置文件的所有配置 Enumeration<Object> keys = properties.keys(); while (keys.hasMoreElements()){ String key = keys.nextElement().toString(); String value = properties.getProperty(key); try { // 创建对象 Object o = Class.forName(value).newInstance(); // 将对象放入集合中 map.put(key,o); } catch (Exception e) { e.printStackTrace(); } } } // 从容器中获取对象 public static Object getBean(String key){ return map.get(key); } }创建Dao对象的调用者StudentService
public class StudentService { public Student findStudentById(int id){ // 从容器中获取对象 StudentDao studentDao = (StudentDao) Container.getBean("studentDao"); System.out.println(studentDao.hashCode()); return studentDao.findById(id); } }测试StudentService
public class Test { public static void main(String[] args) { StudentService studentService = new StudentService(); System.out.println(studentService.findStudentById(1)); System.out.println(studentService.findStudentById(1)); } }
测试结果：
StudentService从容器中每次拿到的都是同一个StudentDao对象，节约了资源。
如果想使用StudentDaoImpl2对象，只需要修改bean.properties的内容为
studentDao=com.Spring.dao.StudentDaoImpl2即可，无需修改Java源码。
Spring实现IOC
接下来我们使用Spring实现IOC，Spring内部也有一个容器用来管理对象。
创建Maven工程，引入依赖
<dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.3.13</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope> </dependency> </dependencies>创建POJO类、Dao类和接口
public class Student { private int id; private String name; private String address; // 省略getter/setter/构造方法/tostring } public interface StudentDao { // 根据id查询学生 Student findById(int id); } public class StudentDaoImpl implements StudentDao{ @Override public Student findById(int id) { // 模拟从数据库查找出学生 return new Student(1,"张三","北京"); } }编写xml配置文件，配置文件中配置需要Spring帮我们创建的对象。
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="studentDao" class="com.Spring.dao.StudentDaoImpl"></bean> </beans>测试从Spring容器中获取对象。
public class TestContainer { @Test public void t1(){ // 创建Spring容器 ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); // 从容器获取对象 StudentDao studentDao1 = (StudentDao) ac.getBean("studentDao"); StudentDao studentDao2 = (StudentDao) ac.getBean("studentDao"); System.out.println(studentDao1.hashCode()); System.out.println(studentDao2.hashCode()); System.out.println(studentDao1.findById(1)); } }
Spring容器类型
容器接口
BeanFactory：BeanFactory是Spring容器中的顶层接口，它可以对Bean对象进行管理。
ApplicationContext：ApplicationContext是BeanFactory的子接口。它除了继承 BeanFactory的所有功能外，还添加了对国际化、资源访问、事件传播等方面的良好支持。
ApplicationContext有以下三个常用实现类：
容器实现类
ClassPathXmlApplicationContext：该类可以从项目中读取配置文件FileSystemXmlApplicationContext：该类从磁盘中读取配置文件AnnotationConfigApplicationContext：使用该类不读取配置文件，而是会读取注解
@Test
public void t2(){
// 创建spring容器
// ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
ApplicationContext ac = new FileSystemXmlApplicationContext
("C:\\Users\\a\\IdeaProjects\\spring_demo\\src\\main\\resources\\bean.xml");
// 从容器中获取对象
StudentDao userDao = (StudentDao) ac.getBean("studentDao");
System.out.println(userDao);
System.out.println(userDao.findById(1));
}
对象的创建方式
Spring会帮助我们创建bean，那么它底层是调用什么方法进行创建的呢？
使用构造方法
Spring默认使用类的空参构造方法创建bean：
// 假如类没有空参构造方法，将无法完成bean的创建
public class StudentDaoImpl implements StudentDao{
public StudentDaoImpl(int a){}
@Override
public Student findById(int id) {
// 模拟根据id查询学生
return new Student(1,"张三","北京");
}
}
使用工厂类的方法
Spring可以调用工厂类的方法创建bean：
创建工厂类，工厂类提供创建对象的方法：
public class StudentDaoFactory { public StudentDao getStudentDao(){ return new StudentDaoImpl(1); } }在配置文件中配置创建bean的方式为工厂方式。
<!-- id：工厂对象的id，class：工厂类 --> <bean id="studentDaoFactory" class="com.Spring.dao.StudentDaoFactory"></bean> <!-- id：bean对象的id，factory-bean：工厂对象的id，factory-method：工厂方法 --> <bean id="studentDao" factory-bean="studentDaoFactory" factory-method="getStudentDao"></bean>测试
使用工厂类的静态方法
Spring可以调用工厂类的静态方法创建bean：
创建工厂类，工厂提供创建对象的静态方法。
public class StudentDaoFactory2 { public static StudentDao getStudentDao2() { return new StudentDaoImpl(); } }在配置文件中配置创建bean的方式为工厂静态方法。
<!-- id:bean的id class:工厂全类名 factory-method:工厂静态方法 --> <bean id="studentDao" class="com.Spring.dao.StudentDaoFactory2" factory-method="getStudentDao2"></bean>测试
对象的创建策略
Spring通过配置<bean>中的scope属性设置对象的创建策略，共有五种创建策略：
singleton：单例，默认策略。整个项目只会创建一个对象，通过
<bean>中的lazy-init属性可以设置单例对象的创建时机：lazy-init="false"(默认)：立即创建，在容器启动时会创建配置文件中的所有Bean对象。
lazy-init="true"：延迟创建，第一次使用Bean对象时才会创建。
配置单例策略：
<!-- <bean id="studentDao" class="com.Spring.dao.StudentDaoImpl2" scope="singleton" lazy-init="true"></bean>--> <bean id="studentDao" class="com.Spring.dao.StudentDaoImpl2" scope="singleton" lazy-init="false"> </bean>测试单例策略：
// 为Bean对象的类添加构造方法 public StudentDaoImpl2(){ System.out.println("创建StudentDao！！！"); } @Test public void t2(){ // 创建Spring容器 ApplicationContext ac = new ClassPathXmlApplicationContext("bean1.xml"); // 从容器获取对象 StudentDao studentDao1 = (StudentDao) ac.getBean("studentDao"); StudentDao studentDao2 = (StudentDao) ac.getBean("studentDao"); StudentDao studentDao3 = (StudentDao) ac.getBean("studentDao"); System.out.println(studentDao1.hashCode()); System.out.println(studentDao2.hashCode()); System.out.println(studentDao3.hashCode()); }prototype：多例，每次从容器中获取时都会创建对象。
<!-- 配置多例策略 --> <bean id="studentDao" class="com.Spring.dao.StudentDaoImpl2" scope="prototype"></bean>request：每次请求创建一个对象，只在web环境有效。
session：每次会话创建一个对象，只在web环境有效。
gloabal-session：一次集群环境的会话创建一个对象，只在web环境有效。
对象的销毁时机
对象的创建策略不同，销毁时机也不同：
- singleton：对象随着容器的销毁而销毁。
- prototype：使用JAVA垃圾回收机制销毁对象。
- request：当处理请求结束，bean实例将被销毁。
- session：当HTTP Session最终被废弃的时候，bean也会被销毁掉。
- gloabal-session：集群环境下的session销毁，bean实例也将被销毁。
生命周期方法
Bean对象的生命周期包含创建——使用——销毁，Spring可以配置Bean对象在创建和销毁时自动执行的方法：
定义生命周期方法
public class StudentDaoImpl2 implements StudentDao{ // 创建时自动执行的方法 public void init(){ System.out.println("创建StudentDao！！！"); } // 销毁时自动执行的方法 public void destory(){ System.out.println("销毁StudentDao！！！"); } }配置生命周期方法
<!-- init-method:创建对象时执行的方法 destroy-method:销毁对象时执行的方法 --> <bean id="studentDao" class="com.Spring.dao.StudentDaoImpl2" scope="singleton" init-method="init" destroy-method="destory"></bean>测试
@Test public void t3(){ // 创建Spring容器 ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean1.xml"); // 销毁Spring容器，ClassPathXmlApplicationContext才有销毁容器的方法 ac.close(); }
获取Bean对象的方式
Spring有多种获取容器中对象的方式：
通过id/name获取
配置文件
<bean name="studentDao" class="com.Spring.dao.StudentDaoImpl2"></bean> || <bean id="studentDao" class="com.Spring.dao.StudentDaoImpl2"></bean>获取对象
StudentDao studentDao = (StudentDao) ac.getBean("studentDao");
通过类型获取
配置文件
<bean name="studentDao" class="com.Spring.dao.StudentDaoImpl2"></bean>获取对象
StudentDao studentDao2 = ac.getBean(StudentDao.class);可以看到使用类型获取不需要强转。
通过类型+id/name获取
虽然使用类型获取==不需要强转==，但如果在容器中有一个接口的多个实现类对象，则获取时会报错，此时需要使用类型+id/name获取
配置文件
<bean name="studentDao" class="com.Spring.dao.StudentDaoImpl2"></bean> <bean name="studentDao1" class="com.Spring.dao.StudentDaoImpl"></bean>获取对象
StudentDao studentDao2 = ac.getBean("studentDao",StudentDao.class);
