基本概念
IOC与大家熟知的依赖注入同理，这是一个通过依赖注入对象的过程 也就是说，它们所使用的对象，是通过构造函数参数，工厂方法的参数或这是从工厂方法的构造函数或返回值的对象实例设置的属性，然后容器在创建bean时注入这些需要的依赖。 这个过程相对普通创建对象的过程是反向的（因此称之为IoC），bean本身通过直接构造类来控制依赖关系的实例化或位置，或提供诸如服务定位器模式之类的机制。
1、谁控制谁：在之前的编码过程中，都是需要什么对象自己去创建什么对象，有程序员自己来控制对象，而有了IOC容器之后，就会变成由IOC容器来控制对象，
2、控制什么：在实现过程中所需要的对象及需要依赖的对象
3、什么是反转：在没有IOC容器之前我们都是在对象中主动去创建依赖的对象，这是正转的，而有了IOC之后，依赖的对象直接由IOC容器创建后注入到对象中，由主动创建变成了被动接受，这是反转
4、哪些方面被反转：依赖的对象
DI与IOC
IOC和DI是从不同的角度描述的同一件事，IOC是从容器的角度描述，而DI是从应用程序的角度来描述，也可以这样说，IOC是设计思想，而DI是具体的实现方式
解耦
使用maven的方式来构建项目
导包 添加对应的pom依赖
<dependencies><!-- https://mvnrepository.com/artifact/org.springframework/spring-context --><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.3.RELEASE</version></dependency></dependencies>
spring对象的获取及属性赋值方式
1、通过bean的id获取IOC容器中的对象
ApplicationContext context = new ClassPathXmlApplicationContext("ioc.xml");Person person = (Person) context.getBean("person");System.out.println(person);
2、通过bean的类型获取对象
ApplicationContext context = new ClassPathXmlApplicationContext("ioc.xml");
Person bean = context.getBean(Person.class);
System.out.println(bean);
3、通过构造器给bean对象赋值
<!--使用构造器方法赋值的时候，参数的name是由构造方法的参数名称决定的-->
<bean id = "person2" class="com.petrel.bean.Person"><constructor-arg name="id" value="2"></constructor-arg><constructor-arg name="name" value="lisi"></constructor-arg><constructor-arg name="age" value="22"></constructor-arg><constructor-arg name="gender" value="男"></constructor-arg>
</bean>
<!--当通过构造器方法赋值的时候，可以把name属性省略不写，但是要注意必须要保证参数值跟构造器的参数列表的顺序一致
如果非要不一致的话，可以通过index的下标方式来标注，从0开始-->
<bean id = "person3" class="com.petrel.bean.Person"><constructor-arg value="3" index="0"></constructor-arg><constructor-arg value="lisi"></constructor-arg><constructor-arg value="22"></constructor-arg><constructor-arg value="男"></constructor-arg>
</bean>
<!--当有多个相同参数的构造方法存在的时候，默认情况下是覆盖的过程，后面的构造方法会覆盖前面的构造方法
如果非要赋值给另外一个构造方法的话，可以使用type的参数来进行指定
/* public Person(int id, String name, Integer age) {this.id = id;this.name = name;this.age = age;System.out.println("age......"); } public Person(int id, String name, String gender) {this.id = id;this.name = name;this.gender = gender;System.out.println("gender....."); } 就是这个地方 没加type="java.lang.Integer"会输出gender=22，加了type之后就输出age=22 还有还有一个注意的点是这里不会自动拆箱，所以定义的时候建议使用Integer类型 -->*/
<bean id = "person4" class="com.petrel.bean.Person"><constructor-arg value="3" index="0"></constructor-arg><constructor-arg value="lisi"></constructor-arg><constructor-arg value="22" type="java.lang.Integer"></constructor-arg>
</bean><!-- name:表示参数列表的名称value:表示实际的具体值type:表示值的类型index:表示值的下标，从0开始在日常工作中，一般都是用name,value的方式，很少有人去使用index或者type的方式，但是要注意各种情况出现的问题-->4、通过命名空间为bean赋值，简化配置文件中属性声明的写法
1、导入命名空间
xmlns:p="http://www.springframework.org/schema/p"
2、添加配置
<!--使用p命名空间来给属性赋值-->
<bean id="person5" class="com.petrel.bean.Person" p:id="5" p:name="wangwu" p:age="25" p:gender="女">
</bean>
5、为复杂类型进行赋值操作
Person.java
private String[] hobbies;private Address address;private List<Address> lists;private Set<String> sets;private Map<String,Object> maps;private Properties properties;public String[] getHobbies() {return hobbies;}public void setHobbies(String[] hobbies) {this.hobbies = hobbies;}public Address getAddress() {return address;}public void setAddress(Address address) {this.address = address;}public List<Address> getLists() {return lists;}public void setLists(List<Address> lists) {this.lists = lists;}public Set<String> getSets() {return sets;}public void setSets(Set<String> sets) {this.sets = sets;}public Map<String, Object> getMaps() {return maps;}public void setMaps(Map<String, Object> maps) {this.maps = maps;}public Properties getProperties() {return properties;}public void setProperties(Properties properties) {this.properties = properties;}Address.java
package com.petrel.bean;public class Address {private String province;private String city;private String town;public Address() {System.out.println("address被创建");}public String getProvince() {return province;}public void setProvince(String province) {this.province = province;}public String getCity() {return city;}public void setCity(String city) {this.city = city;}public String getTown() {return town;}public void setTown(String town) {this.town = town;}@Overridepublic String toString() {return "Address{" +"province='" + province + '\'' +", city='" + city + '\'' +", town='" + town + '\'' +'}';}
}
<!--给复杂类型进行赋值操作-->
<bean id="person6" class="com.petrel.bean.Person"><property name="id" value="6"></property><property name="name" value="zhangsan6"></property><property name="age" value="26"></property><property name="gender" value="男6"></property><!--给数组赋值,使用array标签--><!-- 方法1 <property name="hobbies" value="book,girl,movie"></property>--><property name="hobbies"><array><value>book</value><value>girl</value><value>movie</value></array></property><!--给引用类型赋值,可以使用ref引入外部bean--><property name="address" ref="address"></property><!--给list赋值--><!--<property name="lists" value="1,2,3"></property>--><property name="lists"><list><!--使用内部bean,无法从IOC容器中直接获取对象的值--><bean id="address2" class="com.petrel.bean.Address"><property name="province" value="北京"></property></bean><bean class="com.petrel.bean.Address"><property name="province" value="上海"></property></bean><!--使用外部bean，可以随意从IOC容器获取对象的值--><ref bean="address"></ref></list></property><!--给set属性赋值--><property name="sets"><set><value>zhangsan</value><value>zhangsan</value><value>lisi</value></set></property><!--给map赋值--><property name="maps"><map><entry key="a" value="aaa"></entry><entry key="address" value-ref="address"></entry><entry key="address2"><bean class="com.petrel.bean.Address"><property name="province" value="广东省"></property></bean></entry><entry><key><value>heihei</value></key><value>haha</value></entry><entry key="list"><list><value>11</value><value>22</value></list></entry></map></property><!--给properties赋值--><property name="properties"><props><prop key="111">aaa</prop><prop key="222">bbb</prop></props></property></bean><bean id="address" class="com.petrel.bean.Address"><property name="province" value="河北省"></property><property name="city" value="邯郸"></property><property name="town" value="武安"></property></bean>
6、继承关系bean的配置
<!--bean之间的继承关系--><!--可以使用abstract标签定义抽象bean，无法进行实例化 abstract="true"--><bean id="parent" class="com.petrel.bean.Person" abstract="false"><property name="id" value="1"></property><property name="name" value="zhangsan"></property><property name="age" value="20"></property><property name="gender" value="男"></property></bean><!--可以通过parent属性来获取父bean中的某些属性值--><bean id="son" class="com.petrel.bean.Person" parent="parent"><property name="name" value="haha"></property></bean>7、bean对象创建的依赖关系
<!--创建bean的时候依赖关系当bean对象被创建的时候，是按照xml配置文件定义的顺序创建的，谁在前，谁就先被创建如果需要干扰创建的顺序，可以使用depends-on属性一般在实际工作中不必在意bean创建的顺序，无论谁先创建，需要依赖的对象在创建完成之后都会进行赋值操作<bean id="address" class="com.petrel.bean.Address" depends-on="person"></bean><bean id="person" class="com.petrel.bean.Person"></bean>-->
8、bean的作用域控制，是否是单例
<!--bean的作用域：singleton、prototype、request、session默认情况下是单例的prototype：多实例的容器启动的时候不会创建多实例bean，只有在获取对象的时候才会创建该对象每次创建都是一个新的对象singleton：默认的单例对象在容器启动完成之前就已经创建好对象获取的所有对象都是同一个--><bean id="person4" class="com.petrel.bean.Person" scope="prototype"></bean>
1~8
1-8所有bean对象的创建都是通过反射得到对应的bean实例，在spring中还可以通过工厂模式进行对象的创建
/*** 当需要从容器中获取对象的时候，最好要保留无参构造方法，因为底层的实现是反射** Class clazz = Person.class;* Object obj = clazz.newInstance();默认调用无参的构造方法，此方法已经被弃用* Object obj = class.getDeclaredConstructor().newInstance()**/
9、利用工厂模式创建bean对象
工厂模式创建bean实例的时候有两种方式：静态工厂和实例工厂
- 静态工厂：工厂本身不需要创建对象，但是可以通过静态方法调用，对象=工厂类.静态工厂方法名（）；
- 实例工厂：工厂本身需要创建对象，工厂类 工厂对象=new 工厂类；工厂对象.get对象名（）；
静态工厂
//PersonStaticFactory.java
public class PersonStaticFactory {public static Person getPerson(String name){Person person = new Person();person.setId(1);person.setName(name);return person;}
}
//ioc.xml
<!--
静态工厂的使用：
class:指定静态工厂类
factory-method:指定哪个方法是工厂方法
-->
<bean id="person5" class="com.petrel.factory.PersonStaticFactory" factory-method="getPerson"><!--constructor-arg：可以为方法指定参数--><constructor-arg value="lisi"></constructor-arg></bean>
实例工厂（更容易扩展
）
//PersonInstanceFactory.java
public class PersonInstanceFactory {public Person getPerson(String name){Person person = new Person();person.setId(1);person.setName(name);return person;}
}
//ioc.xml<!--实例工厂使用--><!--创建实例工厂类--><bean id="personInstanceFactory" class="com.petrel.factory.PersonInstanceFactory"></bean><!--factory-bean:指定使用哪个工厂实例factory-method:指定使用哪个工厂实例的方法--><bean id="person6" class="com.petrel.bean.Person" factory-bean="personInstanceFactory" factory-method="getPerson"><constructor-arg value="wangwu"></constructor-arg></bean>
10、继承FactoryBean来创建对象
FactoryBean是Spring规定的一个接口，当前接口的实现类，Spring都会将其作为一个工厂，但是在ioc容器启动的时候不会创建实例，只有在使用的时候才会创建对象
BeanFactory（接口）：规范 有很多方法
FactoryBean（接口）：获取唯一的一个对象
//MyFactoryBean.java
/*** 实现了FactoryBean接口的类是Spring中可以识别的工厂类，spring会自动调用工厂方法创建实例*/
public class MyFactoryBean implements FactoryBean<Person> {/*** 工厂方法，返回需要创建的对象* @return* @throws Exception*/@Overridepublic Person getObject() throws Exception {Person person = new Person();person.setName("maliu");return person;}/*** 返回创建对象的类型,spring会自动调用该方法返回对象的类型* @return*/@Overridepublic Class<?> getObjectType() {return Person.class;}/*** 创建的对象是否是单例对象* @return*/@Overridepublic boolean isSingleton() {return false;}
}
//ioc.xml
<bean id="myfactorybean" class="com.petrel.factory.MyFactoryBean"></bean>
11、bean对象的初始化和销毁方法
//Address.javapublic void init(){System.out.println("对象被初始化");}public void destory(){System.out.println("对象被销毁");}
//ioc.xml
<!--bean生命周期表示bean的创建到销毁如果bean是单例，容器在启动的时候会创建好，关闭的时候会销毁创建的bean如果bean是多例，获取的时候创建对象，销毁的时候不会有任何的调用--><bean id="address" class="com.petrel.bean.Address" init-method="init" destroy-method="destory"></bean>
//MyTest.java
public class MyTest {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("ioc.xml");Address address = context.getBean("address", Address.class);System.out.println(address);//applicationContext没有close方法，需要使用具体的子类((ClassPathXmlApplicationContext)context).close();}
}
12、配置bean对象初始化方法的前后处理方法
spring中包含一个BeanPostProcessor的接口，可以在bean的初始化方法的前后调用该方法，如果配置了初始化方法的前置和后置处理器，无论是否包含初始化方法，都会进行调用
//MyBeanPostProcessor.java
public class MyBeanPostProcessor implements BeanPostProcessor {/*** 在初始化方法调用之前执行* @param bean 初始化的bean对象* @param beanName xml配置文件中的bean的id属性* @return* @throws BeansException*/@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {System.out.println("postProcessBeforeInitialization:"+beanName+"调用初始化前置方法");return bean;}/*** 在初始化方法调用之后执行* @param bean* @param beanName* @return* @throws BeansException*/@Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {System.out.println("postProcessAfterInitialization:"+beanName+"调用初始化后缀方法");return bean;}
}
//ioc.xml
<bean id="myBeanPostProcessor" class="com.petrel.bean.MyBeanPostProcessor"></bean>
spring创建第三方bean对象
需要使用某些外部的单实例对象，例如数据库连接池
1、导入数据库连接池的pom文件
<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.21</version>
</dependency>
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.47</version>
</dependency>
2、编写配置文件
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="username" value="root"></property><property name="password" value="123456"></property><property name="url" value="jdbc:mysql://localhost:3306/demo"></property><property name="driverClassName" value="com.mysql.jdbc.Driver"></property></bean>
3、编写测试文件
public class MyTest {public static void main(String[] args) throws SQLException {ApplicationContext context = new ClassPathXmlApplicationContext("ioc3.xml");DruidDataSource dataSource = context.getBean("dataSource", DruidDataSource.class);System.out.println(dataSource);System.out.println(dataSource.getConnection());}
}
spring引用外部配置文件
1、在resource中添加dbconfig.properties
username=root
password=root
url=jdbc:mysql://localhost:3306/demo
driverClassName=com.mysql.jdbc.Driver
2、编写配置文件
<!--加载外部配置文件在加载外部依赖文件的时候需要context命名空间--><context:property-placeholder location="classpath:dbconfig.properties"/><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="username" value="${username}"></property><property name="password" value="${password}"></property><property name="url" value="${url}"></property><property name="driverClassName" value="${driverClassName}"></property></bean>
spring基于xml文件的自动装配
当一个对象中需要引用另外一个对象的时候，在之前的配置中我们都是通过property标签来进行手动配置的，其实在spring中还提供了一个非常强大的功能就是自动装配，可以按照我们指定的规则进行配置，配置的方式有以下几种：
? default/no：不自动装配
? byName：按照名字进行装配，以属性名作为id去容器中查找组件，进行赋值，如果找不到则装配null
? byType：按照类型进行装配,以属性的类型作为查找依据去容器中找到这个组件，如果有多个类型相同的bean对象，那么会报异常，如果找不到则装配null
? constructor：按照构造器进行装配，先按照有参构造器参数的类型进行装配，没有就直接装配null；如果按照类型找到了多个，那么就使用参数名作为id继续匹配，找到就装配，找不到就装配null
<?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="address" class="com.petrel.bean.Address"><property name="province" value="河北"></property><property name="city" value="邯郸"></property><property name="town" value="武安"></property></bean><bean id="person" class="com.petrel.bean.Person" autowire="byName"></bean><bean id="person2" class="com.petrel.bean.Person" autowire="byType"></bean><bean id="person3" class="com.petrel.bean.Person" autowire="constructor"></bean>
</beans>
SpEL的使用
SpEL:Spring Expression Language,spring的表达式语言，支持运行时查询操作对象
? 使用#{…}作为语法规则，所有的大括号中的字符都认为是SpEL.
<bean id="person4" class="com.petrel.bean.Person"><!--支持任何运算符--><property name="age" value="#{12*2}"></property><!--可以引用其他bean的某个属性值--><property name="name" value="#{address.province}"></property><!--引用其他bean--><property name="address" value="#{address}"></property><!--调用静态方法--><property name="hobbies" value="#{T(java.util.UUID).randomUUID().toString().substring(0,4)}"></property><!--调用非静态方法--><property name="gender" value="#{address.getCity()}"></property></bean>
注解
在bean上添加注解，快速将bean注册到ioc容器
1、使用注解的方式注册bean到IOC容器中
//applicationContext.xml<!--如果想要将自定义的bean对象添加到IOC容器中，需要在类上添加某些注解Spring中包含4个主要的组件添加注解：@Controller:控制器，推荐给controller层添加此注解@Service:业务逻辑，推荐给业务逻辑层添加此注解@Repository:仓库管理，推荐给数据访问层添加此注解@Component:给不属于以上基层的组件添加此注解注意：我们虽然人为的给不同的层添加不同的注解，但是在spring看来，可以在任意层添加任意注解spring底层是不会给具体的层次验证注解，这样写的目的只是为了提高可读性，最偷懒的方式就是给所有想交由IOC容器管理的bean对象添加component注解使用注解需要如下步骤：1、添加上述四个注解中的任意一个2、添加自动扫描注解的组件，此操作需要依赖context命名空间3、添加自动扫描的标签context:component-scan注意：当使用注解注册组件和使用配置文件注册组件是一样的，但是要注意：1、组件的id默认就是组件的类名首字符小写，如果非要改名字的话，直接在注解中添加即可2、组件默认情况下都是单例的,如果需要配置多例模式的话，可以在注解下添加@Scope注解--><!--定义自动扫描的基础包:base-package:指定扫描的基础包，spring在启动的时候会将基础包及子包下所有加了注解的类都自动扫描进IOC容器--><context:component-scan base-package="com.petrel"></context:component-scan>
</beans>//PersonController.java
@Controller
public class PersonController {public PersonController() {System.out.println("创建对象");}
}//PersonService.java
@Service
public class PersonService {
}//PersonDao.java
@Repository("personDao")
@Scope(value="prototype")
public class PersonDao {
}
2、定义扫描包时要包含的类和不要包含的类
有选择性的配置是否要注册bean到IOC容器中
<context:component-scan base-package="com.petrel" use-default-filters="false"><!--当定义好基础扫描的包之后，可以排除包中的某些类，使用如下的方式:type:表示指定过滤的规则annotation：按照注解进行排除，标注了指定注解的组件不要,expression表示要过滤的注解assignable：指定排除某个具体的类，按照类排除，expression表示不注册的具体类名aspectj：后面讲aop的时候说明要使用的aspectj表达式，不用custom：定义一个typeFilter,自己写代码决定哪些类被过滤掉，不用regex：使用正则表达式过滤，不用-->
<!-- <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>--><!--指定只扫描哪些组件，默认情况下是全部扫描的，所以此时要配置的话需要在component-scan标签中添加 use-default-filters="false"--><context:include-filter type="assignable" expression="com.petrel.service.PersonService"/></context:component-scan>
</beans>
3、使用@AutoWired进行自动注入
使用注解的方式实现自动注入
//PersonController.java
@Controller
public class PersonController {@Autowiredprivate PersonService personService;public PersonController() {System.out.println("创建对象");}public void getPerson(){personService.getPerson();}
}//PersonService.java
@Service
public class PersonService {@Autowiredprivate PersonDao personDao;public void getPerson(){personDao.getPerson();}
}
//PersonDao.java
@Repository
public class PersonDao {public void getPerson(){System.out.println("PersonDao:getPerson");}
}/*当使用AutoWired注解的时候，自动装配的时候是根据类型实现的。 ? 1、如果只找到一个，则直接进行赋值， ? 2、如果没有找到，则直接抛出异常， ? 3、如果找到多个，那么会按照变量名作为id继续匹配, ? 1、匹配上直接进行装配 ? 2、如果匹配不上则直接报异常*///PersonServiceExt.java
@Service
public class PersonServiceExt extends PersonService{@Autowiredprivate PersonDao personDao;public void getPerson(){System.out.println("PersonServiceExt......");personDao.getPerson();}
}//PersonController.java
@Controller
public class PersonController {@Autowiredprivate PersonService personServiceExt;public PersonController() {System.out.println("创建对象");}public void getPerson(){personServiceExt.getPerson();}
}还可以使用@Qualifier注解来指定id的名称，让spring不要使用变量名,当使用@Qualifier注解的时候也会有两种情况：
? 1、找到，则直接装配
? 2、找不到，就会报错//PersonController.java
@Controller
public class PersonController {@Autowired@Qualifier("personService")private PersonService personServiceExt2;public PersonController() {System.out.println("创建对象");}public void getPerson(){personServiceExt2.getPerson();}
}
4、@AutoWired可以进行定义在方法上
package com.petrel.controller;import com.petrel.dao.PersonDao;
import com.petrel.service.PersonService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;@Controller
public class PersonController {@Qualifier("personService")@Autowiredprivate PersonService personServiceExt2;public PersonController() {System.out.println("创建对象");}public void getPerson(){System.out.println("personController..."+personServiceExt2);
// personServiceExt2.getPerson();}/*** 当方法上有@AutoWired注解时：* 1、此方法在bean创建的时候会自动调用* 2、这个方法的每一个参数都会自动注入值* @param personDao*/@Autowiredpublic void test(PersonDao personDao){System.out.println("此方法被调用:"+personDao);}/*** @Qualifier注解也可以作用在属性上，用来被当作id去匹配容器中的对象，如果没有* 此注解，那么直接按照类型进行匹配* @param personService*/@Autowiredpublic void test2(@Qualifier("personServiceExt") PersonService personService){System.out.println("此方法被调用："+personService);}
}
5、自动装配的注解@AutoWired，@Resource
在使用自动装配的时候，除了可以使用@AutoWired注解之外，还可以使用@Resource注解
- 1、@AutoWired:是spring中提供的注解，@Resource:是jdk中定义的注解，依靠的是java的标准
- 2、@AutoWired默认是按照类型进行装配，默认情况下要求依赖的对象必须存在，@Resource默认是按照名字进行匹配的，同时可以指定name属性。
- 3、@AutoWired只适合spring框架，而@Resource扩展性更好
@Controller
public class PersonController {@Qualifier("personService")@Resourceprivate PersonService personServiceExt2;public PersonController() {System.out.println("创建对象");}public void getPerson(){System.out.println("personController..."+personServiceExt2);personServiceExt2.getPerson();}/*** 当方法上有@AutoWired注解时：* 1、此方法在bean创建的时候会自动调用* 2、这个方法的每一个参数都会自动注入值* @param personDao*/@Autowiredpublic void test(PersonDao personDao){System.out.println("此方法被调用:"+personDao);}/*** @Qualifier注解也可以作用在属性上，用来被当作id去匹配容器中的对象，如果没有* 此注解，那么直接按照类型进行匹配* @param personService*/@Autowiredpublic void test2(@Qualifier("personServiceExt") PersonService personService){System.out.println("此方法被调用："+personService);}
}