IOC容器工厂只负责创建对象，而Spring当然不仅仅是一个对象工厂，其核心是一个对象容器，其具备控制反转的能力，所以也称为IOC容器。帮助我们存放对象，并且管理对象，包括：创建、销毁、装配，这样就将原本由程序自己完成的工作，交给了框架来完成，称为IOC容器。学习的核心也就在于如何将对象放在Spring中，以及如何从Spring中取出来。Spring有两个容器接口：ApplicationContext
BeanFactory
ApplicationContext是BeanFactory的子接口，它们都可以作为Spring的容器。区别：BeanFactory采取懒加载方式（会有延迟），在获取对象时才会实例化
ApplicationContext在工厂初始化时立即实例化对象
BeanFactory作为顶级接口主要面向于Spring框架本身，仅提供了基本的容器功能，如DI
ApplicationContext时BeanFactory的子接口，意味着功能比BeanFactory更多，诸如国际化（根据用户的地理位置对产品的表现形式进行一些变化，例如文字、样式），注解配置，XML配置等等，因此ApplicationContext使用更多
ApplicationContext的个实现类的区别：
ClassPath表示从类路径获取配置文件
FileSystem表示从文件系统获取配置文件Spring Bean管理Bean的实例化（初始化，相当于我们之前的new）1.创建一个maven项目
2.配置maven

org.springframework
spring-context
5.2.2.RELEASE



3.在resource下创建一个名为applicationContext.xml的配置文件
自动生成：在这里配置Bean<?xml version="1.0" encoding="UTF-8"?>

4.创建contoller、service对应的包
准备工作已完成，下面书写Bean实例化的方式方式一 使用无参构造器使用该方式时，Bean类中必须要有无参构造
测试public class UserController {
private UserService service;
public UserController() {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(“applicationContext.xml”);
//通过指定文件路径加载Spring配置文件，一般很少用
//FileSystemXmlApplicationContext context = new FileSystemXmlApplicationContext(“D:\ideaProject\SpringDemo2\src\main\resources\applicationContext.xml”);

    //根据id或name获取service = (UserService) context.getBean("userService");//通过接口类来获取//service = context.getBean(UserService.class);//通过具体类来获取//service = context.getBean(UserServiceImpl.class);
}
public void say(){service.say();
}public static void main(String[] args) {new UserController().say();
}

}
方式二 使用静态工厂方式创建一个工厂类public class factory {
public static UserService getService(){
System.out.println(“执行了静态工厂方法”);
return new UserServiceImpl();
}
}xml配置

方式三 使用实例工厂方式xml文件



调用：service = (UserService) context.getBean(“userService3”);
首先需配置工厂类，然后通过factory-bean调用刚刚命名的那个Bean，写入id，用factory-method指定要使用的工厂的方法。Bean的命名配置Bean时，可以使用 id 或者 name 属性给bean命名。 id 和 name 属性作用上一样，推荐使用id。id取值要求严格些，必须满足XML的命名规范。id是唯一的，配置文件中不允许出现两个id相同的bean。name取值比较随意，甚至可以用数字开头。在配置文件中允许出现多个name相同的bean，在用getBean()返回实例时，最后的一个Bean将被返回。注意:在spring5中name和id一样也不允许有重复的名称。如果没有id，name，则默认使用类的全名作为name，如 ,可以使用 getBean(“com.cx.service.UserService”)返回该实例。如果存在多个id和name都没有指定，且类都一样的，如:则可以通过getBean(“完整类名#索引”)来获得,如:getBean(“com.cx.service.UserService#1”),索引从0开始,若要获取第一个则可以忽略索引,直接写类名。name中可以使用分号（“；”）、空格（“ ”）或逗号（“，”）来给这个Bean添加多个名称（相当于别名 alias 的作用）。如：name=“a b c d”等同于 name=“a,b,c,d” 这样写相当于有 1 2 3 4（4个）个标识符标识当前bean ,而id中的任何字符都被作为一个整体 ;如果既配置了 id ，也配置了 name ，则两个都生效。当然也不能重复;当注解中出现与xml配置中相同的id或相同name时,优先使用xml中的配置Bean的作用域类别 说明
作用域就是指作用范围:单例则表示对象的作用范围是整个Spring容器,而prototype则表示不管理作用范围,每次get就直接创建新的。request、session和 application三种作用域仅在基于web的应用中使用生命周期init和destorySpring提供了非***（不强制类继承或实现）方式的生命周期方法，可以在Bean的初始化以及销毁时做一些额外的操作

注意：
destroy仅仅在scope为singleton时有效Bean的完整生命周期1 构造对象2 设置属性3 了解Bean在容器中的name4 了解关联的beanFactory5 初始化前处理6 属性设置完成7 自定义初始化方法8 初始化后处理9 业务方法10 Bean销毁方法11 自定义销毁方法依赖注入依赖指的是档期啊对象在运行过程中需要使用到的其他参数或者对象；Spring可以帮助我们完成这个依赖关系的建立；说的简单点即把你需要的参数给你，而你不管参数是怎么来的，只管用即可，以达到尽可能地解耦。for examplecontroller中需要service对象，Spring可以把service自动丢到controller中，你不需要关注service对象是怎么来的，用就可以了要使用依赖注入，必须先在需要依赖的一方（controller）中为被依赖的一方（service）定义属性，用于接收注入；构造方法注入bean：
书写userpublic class User {
private Integer id;
private String name;
private String sex;
private PC pc;
}
还有有参/无参构造，getter/setter方法，以及toString
user中需要的pc类public class PC {
private String model;
}在applicationContext.xml中注入，构造方法注入











测试代码： public void test1() {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(“applicationContext.xml”);
User user = (User) context.getBean(“user”);
System.out.println(user);
}

public static void main(String[] args) {new TestController().test1();
}setter方法注入在上述中，还可以使用下述注入 <!--使用setter方法注入（属性注入）-->
<bean id="user2" class="cx.pojo.User"><property name="id" value="2"/><property name="name" value="李四"/><property name="sex" value="男"/><property name="pc" ref="pc" />
</bean>注意：setter方法注入配置要求User中必须有无参构造方法C和P命名标签上面的两种依赖注入方法，如果在需要注入的依赖较多时导致xml显得很臃肿,C名称空间来简化xml中标签的书写。需要先在xml中进行声明xmlns:c="http://www.springframework.org/schema/c"使用：    <!--c命名空间的使用-->
<!--c:id            指定为id参数赋值c:_1                指定为构造函数的第2个参数赋值c:p-ref   指定为构造函数的pc参数赋值为id为"pc"的Bean    -->
<bean id="user3" class="cx.pojo.User" c:id="3" c:_1="王五" c:_2="男" c:pc-ref="pc" />

同理p命名标签也需要在xml中进行声明xmlns:p=“http://www.springframework.org/schema/p”

使用：```java
<!--p:id            指定为id属性赋值p:name          name属性赋值p:sex           sex属性赋值p:pc-ref        为pc属性赋值为id为"pc"的Bean-->
<bean id="user4" class="cx.pojo.User" p:id="4" p:name="赵六" p:sex="女" p:pc-ref="pc"/>
SpEL注入SpEL即Spring Expression Language的缩写,与JSTL一样是表达式语言,可以支持使用更加复杂的语法注入依赖,包括标准数学运算符，关系运算符，逻辑运算符，条件运算符，集合和正则表达式等;语法: #{表达式}用例:<!--SpEL    -->
<bean id="user" class="com.cx.pojo.User">
<!--<property name="name" value="#{'cx'}"/>-->           <!--字符常量-->
<!--<property name="age" value="#{100.0}"/>-->              <!--数字常量-->
<!--<property name="phone" value="#{phone}"/>-->            <!--对象引用-->
<!--<property name="name" value="#{phone.model.concat(' cx')}"/>--> <!--方法调用-->
<!--<property name="age" value="#{1+100}"/>-->              <!--算数符-->
<!--<property name="name" value="#{1>100}"/>-->       <!--比较符-->
<!--<property name="name" value="#{true or false}"/>-->     <!--逻辑符-->
<!--<property name="name" value="#{1 > 0?1:0}"/>-->         <!--三目-->
</bean>
容器类型的注入xml： <bean id="userdemo" class="com.lbb.pojo.UserDemo"><!--注入set--><property name="set"><set><value>1</value><value>2</value><value>3</value><value>4</value></set></property><!--注入list--><property name="list"><list><value>1</value><value>2</value><value>3</value><value>4</value></list></property><!--注入map--><property name="map"><map><entry key="1" value="1"/><entry key="2" value="2"/><entry key="3" value="3"/><entry key="4" value="4"/></map></property><!--注入properties--><property name="properties"><props><prop key="1">1</prop><prop key="2">2</prop><prop key="3">3</prop><prop key="4">4</prop></props></property></bean>
上述写法同样适用于构造函数注入：<bean class="service.Person"><constructor-arg name="name" value="jerry"/><constructor-arg name="properties"><props><prop key="pwd">123</prop></props></constructor-arg></bean>
强调:java Spring的依赖注入要么通过构造函数,要么通过setter接口注入不是一种注入方式,只不过由于OOP的多态,Spring在按照类型注入时,会在容器中查找类型匹配的Bean,如果没有则查找该类的子类,如果容器中有多个匹配的子类Bean时会抛出异常。注解配置注解配置Bean
通用注解​ @Component 用于在Spring中加入BeanMVC场景下@Controller 等价于 @Component 标注控制层@Service 等价于 @Component 标注业务层@Repository 等价于 @Component 标注数据访问层(DAO)在实现上暂时没有任何不同,在底层源码里就是给Component取了别名，仅仅是为了对Bean进行分层是结构更清晰使用步骤:1.需要依赖context和aop两个jar包
2.配置applicationContext.xml
添加命名空间(idea下 输入<context:可自动补全,指定扫描的注解所在的包:<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttps://www.springframework.org/schema/beans/spring-beans.xsd        http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"><!--指定要扫描注解的包 会自动扫描子包   --><context:component-scan base-package="com.cx.pojo"/></beans>
要注册的Bean@Component
public class User {private Integer id;private String name;private String sex;private PC pc;
}测试代码public void test1() {ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");User user = (User) context.getBean("user");System.out.println(user);}如果注解中没有指定id，则默认使用简单类名且小写开头，例如：上述的user。注解注入br/>@value用于对基本类型的注入
@Autowired将容器中的其他Bean注入到属性中，自动装配br/>@Qualifier(“BeanId”)指定要注入的Bean的Id，需要和Autowired一起使用
@Resource 相当于: @Autowired 和@Qualifier 一起使用.
@value    @Value("12")private int age;@Value("tom")private String name;@Value("#{1+2+3}")private String pwd;    @Value("${jdbc.user}") //注入属性配置private String user;上述注入属性配置使用${}取配置文件里面的值：首先需要加载配置文件，在applicationContext.xml加入：<context:property-placeholder location="jdbc.properties"/>@Autowired
自动注入一个Bean，默认按照类型来注入
required属性用于设置属性是否是必须的默认为true，如果为true找不到会报错，如果false则会为空，不会报错使用：
User 类：@Component
public class User {@Value("1")private Integer id;@Value("cc")private String name;@Value("男")private String sex;@Value("小米")private PC pc;
}dao层：@Repository
public class PersonDao {public void smile(){System.out.println("ta笑了");}
}service实现层：@Service
public class PerSonServiceImpl implements PersonService {@Autowiredprivate PersonDao personDao;public void smile(){personDao.smile();}
}接口层public interface PersonService {public void smile();
}controller层@Controller
public class PersonController {@Autowiredprivate PersonService personService;public void smile() {personService.smile();}
}测试：@Testpublic void test1() {ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");PersonController bean = context.getBean(PersonController.class);bean.smile();}        @Qualifier
当我们需要指定注入的bean的id时，Autowired不能配置，这时候要和Qualifier一起使用，用于明确指定要注入的Bean的ID（注意一定要一起使用）使用：上面PersonService可以这样写：@Service
public class PerSonServiceImpl implements PersonService {@Autowired@Qualifier("personDaoImpl")private PersonDao personDao;public void smile(){personDao.smile();}
}
注意:若通过类型注入,则当Spring中存在多个类型都匹配的Bean时直接报错，演示如下：接口:public interface PersonDao {
}两个实现类:@Repository()
public class PersonDaoImpl1 implements PersonDao{
}@Repository()
public class PersonDaoImpl2 implements PersonDao{
}3
注入:@Component
public class UserService {@Autowiredprivate PersonDao personDao;
}这时候就会报错，如果要这样用必须指定Bean的name,通过name来区分。@ResourceQualifier和Autowired书写繁琐,@Resource可将两个标签的功能整合,即注入指定ID的Bean：@Resource标准注解是java注解，但是在jdk中没有导入，要配置导入，在pom.xml配置：<dependency><groupId>javax.annotation</groupId><artifactId>javax.annotation-api</artifactId><version>1.3.2</version>
</dependency>
注解：
Resource默认按照使用属性名称作为name查找,查找失败则使用类型查找可以利用name属性指定要查找的id也可通过type指定类型,当出现相同类型的多个Bean时抛出异常@Service
public class PerSonServiceImpl implements PersonService {@Resource(name = "personDaoImpl")private PersonDao personDao;public void smile(){personDao.smile();}
}
Resource可以设置name，也可以设置type.如果不设置的话，会先按照类型找，找不到会再按照属性名来寻找。Scope用于标注Bean的作用域@Repository()
@Scope("prototype") //每次get都创建新的 
public class PersonDao {public void smile(){System.out.println("笑了");}
}
XML与注解配合使用因为注解的表达能力有限,很多时候无法满足使用需求;我们可以将注解和XML配合使用,让XML负责管理Bean,注解仅负责依赖注入;与注解扫描的不同之处,注解扫描用于将Bean放入容器中同时进行依赖注入,而后者仅仅是在已存在的Bean中进行依赖注入;配置applicationContext.xml文件，开启注解：<!--使用xml默认是不扫描注解的，所以要配置下面开启注解--><context:annotation-config/>多配置文件的使用：当配置文件中的内容过多是不便于维护,Spring支持多配置文件方法1:在初始化容器时指定要加载的所有配置文件 @Testpublic void test3(){//读取配置文件ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml","applicationContext2.xml");//获取beanPersonController personController= (PersonController) context.getBean("personController");personController.smile();}
方法2：在配置文件中使用import来引入其他的配置文件<import resource="applicationContext2.xml"/>
import 里的其他写法:前缀 含义
classpath: 从classpath加载第一个匹配的文件
classpath*: 从classpath加载所有匹配的文件(用于成功分为多个jar包时)
file: 按绝对路径加载文件
http: 按URL路径加载文件
最后来一波~~