一、入门
1、案例
代码示例：实体类
1 public class Student { 2 3 private String name; 4 5 public Student() { 6 System.out.println("Student()..."); 7 } 8 9 public String getName() { 10 return name; 11 } 12 13 public void setName(String name) { 14 this.name = name; 15 System.out.println("setName... " + name); 16 } 17 18 }
1 <!-- 配置bean --> 2 <bean > 3 <property name="name" value="小猪"/> 4 </bean>
代码示例：测试类
1 public class Main { 2 3 public static void main(String[] args) { 4 // 1.原始的创建bean的方式 5 Student student = new Student(); 6 student.setName("工匠"); 7 System.out.println(student.getName()); 8 9 // 2.交给spring去做 10 ApplicationContext app = new ClassPathXmlApplicationContext("app1.xml"); 11 12 Student bean = app.getBean(Student.class); 13 System.out.println(bean.getName()); 14 } 15 }
2、IOC、DI
Spring实际上是一个容器框架，它可以接管web层，业务层，持久层，dao层的各个组件。可以配置各种bean（action/service/domain/dao），并且可以维护bean与bean之间的关系，当我们需要使用某个bean的时候，我们可以getBean()，使用即可。
IOC是什么?
答：控制反转（inverse of controll）：所谓控制反转就是把创建对象（bean）和维护对象（bean）的关系的权利从程序中转移到Spring的容器中（applicationContext.xml），而程序本身不再维护。
DI是什么?
答：依赖注入（dependency injection）：实际上di和ioc是同一个概念，Spring设计者认为di更能准确表示Spring核心技术。
学习框架，最重要的就是学习各个配置。
二、IOC、DI
1、什么是IOC？
控制反转。它不是什么技术，而是一种设计思想。
传统的创建对象的方法是直接通过 new 关键字，而 Spring 则是通过 IOC 容器来创建对象，也就是说我们将创建对象的控制权交给了 IOC 容器。我们可以用一句话来概括 IOC：IOC 让程序员不在关注怎么去创建对象，而是关注对象创建之后的操作，把对象的创建、初始化、销毁等工作交给Spring容器来做。
2、什么是DI依赖注入？
Spring动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。比如对象A需要操作数据库，以前我们总是要在A中自己编写代码来获得一个Connection对象，有了 Spring我们就只需要告诉Spring，A中需要一个Connection，至于这个Connection怎么构造，何时构造，A不需要知道。在系统运行时，Spring会在适当的时候制造一个Connection，然后像打针一样，注射到A当中，这样就完成了对各个对象之间关系的控制。A需要依赖 Connection才能正常运行，而这个Connection是由Spring注入到A中的，依赖注入的名字就这么来的。那么DI是如何实现的呢？Java 1.3之后一个重要特征是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，Spring就是通过反射来实现注入的。
简单来说什么是依赖注入，就是给属性赋值（包括基本数据类型和引用数据类型）。
详情见基本装配。
3、IOC底层原理
xml解析、反射、工厂模式
4、Spring 容器创建对象的三种方式
构造器；利用静态工厂方法；实例工厂方法。
1 # app1.xml 2 <?xml version="1.0" encoding="UTF-8"?> 3 <beans xmlns="http://www.springframework.org/schema/beans" 4 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 5 xsi:schemaLocation="http://www.springframework.org/schema/beans 6 http://www.springframework.org/schema/beans/spring-beans-4.3.xsd"> 7 8 <!-- 在spring的配置文件bean中有一个属性 lazy-init="default/true/false"--> 9 <!-- ①、如果lazy-init为"default/false"在启动spring容器时创建对象（默认情况）--> 10 <!-- ②、如果lazy-init为"true", 表示不预先加载 在context.getBean时才要创建对象--> 11 12 <!-- 方法一：构造器，配置bean --> 13 <bean > 14 <property name="name" value="小猪"/> 15 </bean> 16 17 <!-- 方法二：利用静态工厂方法 --> 18 <!-- spring容器启动时，这句话等价于 19 Object helloIoc = HelloStaticFactory.getInstances(); // 这个静态的工厂方法 return new HelloIoc(); 20 注意：这里 HelloStaticFactory() 构造器并没有执行。换句话说，HelloStaticFactory的bean并没有创建 21 --> 22 <bean /> 23 24 <!-- 方法三：利用实例工厂方法 --> 25 <!-- 26 factory-bean:指定当前Spring中包含工厂方法的beanID 27 factory-method:工厂方法名称 28 29 下面两句话等价于 30 HelloInstanceFactory instanceFactory = new HelloInstanceFactory(); 31 Object instance = instanceFactory.getInstance(); // 这个工厂方法 return new HelloIoc(); 32 --> 33 <bean /> 34 <bean /> 35 36 </beans>
1 // 测试类 2 public class Main { 3 4 public static void main(String[] args) { 5 // 1.原始的创建对象的方式 6 Student student = new Student(); 7 student.setName("工匠"); 8 System.out.println(student.getName()); 9 10 // Spring 容器创建对象的三种方式 11 12 // 2.IOC 13 ApplicationContext app = new ClassPathXmlApplicationContext("app1.xml"); 14 Student bean = app.getBean(Student.class); 15 System.out.println(bean.getName()); 16 17 // 2.1.把ApplicationContext做成一个单例模式 18 ApplicationContext app1 = ApplicationContextUtil.getApplicationContext(); 19 Student bean1 = app1.getBean(Student.class); 20 System.out.println(bean1.getName()); 21 22 // 3.利用静态工厂方法 23 ApplicationContext context = new ClassPathXmlApplicationContext("app1.xml"); 24 HelloIoc helloIoc = (HelloIoc) context.getBean("helloIoc"); 25 helloIoc.sayHello(); 26 27 // 4.利用实例工厂方法 28 ApplicationContext app = new ClassPathXmlApplicationContext("app1.xml"); 29 HelloIoc staticFactory = (HelloIoc) app.getBean("instance"); 30 staticFactory.sayHello(); 31 32 } 33 }
三、Bean工厂和ApplicationContext的区别
1、介绍
bean工厂：最简单的容器，创建分发各种bean，提供了基础的依赖注入支持，创建各种类型的bean。配置好它们之间的协作关系，参与bean的生命周期。
应用上下文（ApplicationContext）：建立在bean工厂基础之上，Spring更加高级的容器，提供系统架构服务。功能强大：提供文本信息解析工具，包括对国际化支持。提供载入文件资源的通用方法，如图片。可以向注册为监听器的bean发送事件。
在很少的情况下，使用BeanFactory，如在移动设备。
2、获取方式
1 ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml"); 2 3 BeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
3、区别（作用域）
使用ApplicationContext，当我们去实例化applicationContext.xml，则配置的bean如果是singleton（默认scope="singleton"），不管是否使用该bean，都会被实例化（好处就是可以预先加载，缺点就是耗内存）。如果不是singleton，则不会被创建。
使用BeanFactory，则当你获取BeanFactory的时候，只是实例化该容器。bean工厂只把bean定义的信息载进来，配置的bean不会被马上实例化，只有用到的时候才实例化。（延迟加载，好处节约内存，缺点就是速度较慢）
代码示例：作用域
1 public class Stu { 2 private String name; 3 private int age; 4 5 public Stu() { 6 System.out.println("Stu()"); // 打印.用于查看构造函数是否调用 7 } 8 } 9 10 application.xml 11 // 配置一：singleton 12 <bean 13 <property name="name" value="lu"/> 14 <property name="age" value="18"/> 15 </bean> 16 17 // 配置二：prototype 18 <bean > 19 <property name="name" value="lu"/> 20 <property name="age" value="18"/> 21 </bean>